@ryuenn3123/agentic-senior-core 1.9.0 → 1.9.2

package/lib/cli/skill-selector.mjs

@@ -0,0 +1,210 @@
+/**
+ * Skill Selector — Skill platform interaction and domain inference.
+ * Depends on: constants.mjs, utils.mjs
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import {
+  SKILL_PLATFORM_DIRECTORY,
+  SKILL_PLATFORM_INDEX_PATH,
+} from './constants.mjs';
+
+import { normalizeChoiceInput } from './utils.mjs';
+
+export async function loadSkillPlatformIndex() {
+  const skillPlatformIndexContent = await fs.readFile(SKILL_PLATFORM_INDEX_PATH, 'utf8');
+  return JSON.parse(skillPlatformIndexContent);
+}
+
+export function normalizeSkillTierInput(rawTierInput) {
+  const normalizedTierInput = normalizeChoiceInput(rawTierInput);
+  const allowedTierNames = new Set(['standard', 'advance', 'expert', 'above']);
+
+  if (!allowedTierNames.has(normalizedTierInput)) {
+    return null;
+  }
+
+  return normalizedTierInput;
+}
+
+export function findSkillDomainByInput(skillDomainInput, skillDomainEntries) {
+  const normalizedSkillDomainInput = normalizeChoiceInput(skillDomainInput);
+
+  return skillDomainEntries.find((skillDomainEntry) => {
+    const normalizedDomainName = normalizeChoiceInput(skillDomainEntry.name);
+    const normalizedDisplayName = normalizeChoiceInput(skillDomainEntry.displayName);
+
+    return normalizedSkillDomainInput === normalizedDomainName || normalizedSkillDomainInput === normalizedDisplayName;
+  }) || null;
+}
+
+export function formatSkillTierList(skillPlatformIndex) {
+  return skillPlatformIndex.tiers.map((tierDefinition) => `${tierDefinition.name} (${tierDefinition.description})`).join('\n');
+}
+
+export function inferSkillDomainNamesFromSelection(selectedStackFileName, selectedBlueprintFileName) {
+  const inferredDomainNames = new Set();
+
+  if (selectedBlueprintFileName === 'api-nextjs.md' || selectedBlueprintFileName === 'fastapi-service.md') {
+    inferredDomainNames.add('frontend');
+    inferredDomainNames.add('fullstack');
+    inferredDomainNames.add('cli');
+  }
+
+  if (selectedBlueprintFileName === 'go-service.md'
+    || selectedBlueprintFileName === 'spring-boot-api.md'
+    || selectedBlueprintFileName === 'laravel-api.md'
+    || selectedBlueprintFileName === 'aspnet-api.md') {
+    inferredDomainNames.add('backend');
+    inferredDomainNames.add('fullstack');
+    inferredDomainNames.add('cli');
+  }
+
+  if (selectedStackFileName === 'typescript.md') {
+    inferredDomainNames.add('frontend');
+    inferredDomainNames.add('cli');
+  }
+
+  if (selectedStackFileName === 'go.md'
+    || selectedStackFileName === 'java.md'
+    || selectedStackFileName === 'php.md'
+    || selectedStackFileName === 'csharp.md'
+    || selectedStackFileName === 'python.md'
+    || selectedStackFileName === 'ruby.md'
+    || selectedStackFileName === 'rust.md') {
+    inferredDomainNames.add('backend');
+  }
+
+  if (selectedStackFileName === 'react-native.md' || selectedStackFileName === 'flutter.md') {
+    inferredDomainNames.add('frontend');
+    inferredDomainNames.add('fullstack');
+    inferredDomainNames.add('cli');
+  }
+
+  if (selectedBlueprintFileName === 'mobile-app.md') {
+    inferredDomainNames.add('frontend');
+    inferredDomainNames.add('fullstack');
+    inferredDomainNames.add('cli');
+  }
+
+  if (selectedBlueprintFileName === 'observability.md') {
+    inferredDomainNames.add('backend');
+    inferredDomainNames.add('fullstack');
+    inferredDomainNames.add('cli');
+  }
+
+  if (inferredDomainNames.size === 0) {
+    inferredDomainNames.add('fullstack');
+    inferredDomainNames.add('cli');
+  }
+
+  return Array.from(inferredDomainNames);
+}
+
+export async function buildSkillPackSection(skillDomainEntry, selectedTierName) {
+  const resolvedPackFileName = skillDomainEntry.tierToPackFileNames?.[selectedTierName]
+    || skillDomainEntry.tierToPackFileNames?.[skillDomainEntry.defaultTier]
+    || skillDomainEntry.defaultPackFileName;
+  const skillPackFilePath = path.join(SKILL_PLATFORM_DIRECTORY, resolvedPackFileName);
+  const skillPackContent = await fs.readFile(skillPackFilePath, 'utf8');
+
+  return [
+    `## SKILL PACK: ${skillDomainEntry.displayName}`,
+    `Source: .agent-context/skills/${resolvedPackFileName}`,
+    `Default tier: ${skillDomainEntry.defaultTier}`,
+    `Selected tier: ${selectedTierName}`,
+    `Evidence: ${skillDomainEntry.evidence}`,
+    '',
+    skillPackContent.trim(),
+    '',
+  ].join('\n');
+}
+
+export async function runSkillCommand(commandArguments) {
+  const parsedSkillOptions = {
+    domain: null,
+    tier: null,
+    tierProvided: false,
+    json: false,
+  };
+
+  for (let argumentIndex = 0; argumentIndex < commandArguments.length; argumentIndex++) {
+    const currentArgument = commandArguments[argumentIndex];
+
+    if (!currentArgument.startsWith('--')) {
+      parsedSkillOptions.domain = currentArgument;
+      continue;
+    }
+
+    if (currentArgument === '--tier') {
+      parsedSkillOptions.tier = normalizeSkillTierInput(commandArguments[argumentIndex + 1] || '');
+      parsedSkillOptions.tierProvided = true;
+      argumentIndex += 1;
+      continue;
+    }
+
+    if (currentArgument.startsWith('--tier=')) {
+      parsedSkillOptions.tier = normalizeSkillTierInput(currentArgument.split('=')[1]);
+      parsedSkillOptions.tierProvided = true;
+      continue;
+    }
+
+    if (currentArgument === '--json') {
+      parsedSkillOptions.json = true;
+      continue;
+    }
+
+    throw new Error(`Unknown option: ${currentArgument}`);
+  }
+
+  const skillPlatformIndex = await loadSkillPlatformIndex();
+  const skillDomainEntries = Object.values(skillPlatformIndex.domains || {});
+  const selectedSkillDomain = parsedSkillOptions.domain
+    ? findSkillDomainByInput(parsedSkillOptions.domain, skillDomainEntries)
+    : null;
+
+  if (parsedSkillOptions.domain && !selectedSkillDomain) {
+    throw new Error(`Unknown skill domain: ${parsedSkillOptions.domain}`);
+  }
+
+  if (parsedSkillOptions.tierProvided && !parsedSkillOptions.tier) {
+    throw new Error(`Unknown skill tier: ${commandArguments.join(' ')}`);
+  }
+
+  const selectedTierName = parsedSkillOptions.tier || skillPlatformIndex.defaultTier || 'advance';
+  const recommendedPackFileName = selectedSkillDomain
+    ? selectedSkillDomain.tierToPackFileNames?.[selectedTierName]
+      || selectedSkillDomain.tierToPackFileNames?.[selectedSkillDomain.defaultTier]
+      || selectedSkillDomain.defaultPackFileName
+      || null
+    : null;
+
+  if (parsedSkillOptions.json) {
+    console.log(JSON.stringify({
+      defaultTier: skillPlatformIndex.defaultTier,
+      selectedTier: selectedTierName,
+      selectedDomain: selectedSkillDomain,
+      recommendedPackFileName,
+    }, null, 2));
+    return;
+  }
+
+  console.log('Skill platform selector');
+  console.log(`Default tier: ${skillPlatformIndex.defaultTier}`);
+  console.log(`Available tiers:\n${formatSkillTierList(skillPlatformIndex)}`);
+
+  if (!selectedSkillDomain) {
+    console.log('\nAvailable domains:');
+    for (const skillDomainEntry of skillDomainEntries) {
+      console.log(`- ${skillDomainEntry.name}: ${skillDomainEntry.description}`);
+    }
+    return;
+  }
+
+  console.log(`\nSelected domain: ${selectedSkillDomain.displayName}`);
+  console.log(`Selected tier: ${selectedTierName}`);
+  console.log(`Recommended pack: ${recommendedPackFileName}`);
+  console.log(`Purpose: ${selectedSkillDomain.description}`);
+  console.log(`Evidence: ${selectedSkillDomain.evidence}`);
+}

package/lib/cli/utils.mjs

@@ -0,0 +1,227 @@
+/**
+ * CLI Utilities — Shared helper functions.
+ * Depends on: constants.mjs
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import {
+  REPO_ROOT,
+  ALLOWED_SEVERITY_LEVELS,
+  PROFILE_PRESETS,
+  entryPointFiles,
+  directoryCopies,
+} from './constants.mjs';
+
+export function printUsage() {
+  console.log('Agentic-Senior-Core CLI');
+  console.log('');
+  console.log('Local runtime:');
+  console.log('  npm exec --yes @ryuenn3123/agentic-senior-core init');
+  console.log('  npx @ryuenn3123/agentic-senior-core init');
+  console.log('  npm install -g @ryuenn3123/agentic-senior-core && agentic-senior-core init');
+  console.log('  bunx @ryuenn3123/agentic-senior-core init   # optional Bun path');
+  console.log('  open GitHub template: https://github.com/fatidaprilian/Agentic-Senior-Core/generate');
+  console.log('');
+  console.log('Usage:');
+  console.log('  agentic-senior-core launch');
+  console.log('  agentic-senior-core init [target-directory] [--preset <name>] [--profile <beginner|balanced|strict>] [--profile-pack <name>] [--stack <name>] [--blueprint <name>] [--ci <true|false>] [--newbie]');
+  console.log('  agentic-senior-core upgrade [target-directory] [--dry-run] [--yes]');
+  console.log('  agentic-senior-core skill [domain] [--tier <standard|advance|expert|above>] [--json]');
+  console.log('  agentic-senior-core --version');
+  console.log('');
+  console.log('Options:');
+  console.log('  --help       Show help');
+  console.log('  --version    Show CLI version');
+  console.log('  --profile    Choose beginner, balanced, or strict');
+  console.log('  --preset     Use a plug-and-play starter preset (frontend-web, backend-api, fullstack-product, platform-governance, mobile-react-native, mobile-flutter, observability-platform)');
+  console.log('  --profile-pack  Apply a team profile pack (startup, regulated, platform)');
+  console.log('  --newbie     Alias for --profile beginner');
+  console.log('  --stack      Override stack selection');
+  console.log('  --blueprint  Override blueprint selection');
+  console.log('  --ci         Override CI/CD guardrails (true|false)');
+  console.log('  --dry-run    Preview upgrade without writing files');
+  console.log('  --yes        Skip confirmation prompts for upgrade');
+  console.log('  --tier       Choose a skill tier for the skill selector');
+  console.log('  --json       Emit machine-readable skill selection output');
+}
+
+export async function pathExists(targetPath) {
+  try {
+    await fs.stat(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function ensureDirectory(directoryPath) {
+  await fs.mkdir(directoryPath, { recursive: true });
+}
+
+export async function copyDirectory(sourceDirectoryPath, targetDirectoryPath) {
+  if (path.resolve(sourceDirectoryPath) === path.resolve(targetDirectoryPath)) {
+    return;
+  }
+
+  await ensureDirectory(targetDirectoryPath);
+  const directoryEntries = await fs.readdir(sourceDirectoryPath, { withFileTypes: true });
+
+  for (const directoryEntry of directoryEntries) {
+    const sourceEntryPath = path.join(sourceDirectoryPath, directoryEntry.name);
+    const targetEntryPath = path.join(targetDirectoryPath, directoryEntry.name);
+
+    if (directoryEntry.isDirectory()) {
+      await copyDirectory(sourceEntryPath, targetEntryPath);
+      continue;
+    }
+
+    if (path.resolve(sourceEntryPath) === path.resolve(targetEntryPath)) {
+      continue;
+    }
+
+    await fs.copyFile(sourceEntryPath, targetEntryPath);
+  }
+}
+
+export async function copyGovernanceAssetsToTarget(resolvedTargetDirectoryPath) {
+  for (const sourceDirectoryName of directoryCopies) {
+    const sourceDirectoryPath = path.join(REPO_ROOT, sourceDirectoryName);
+    if (!(await pathExists(sourceDirectoryPath))) {
+      continue;
+    }
+
+    await copyDirectory(sourceDirectoryPath, path.join(resolvedTargetDirectoryPath, sourceDirectoryName));
+  }
+
+  for (const entryPointFileName of entryPointFiles) {
+    const sourceFilePath = path.join(REPO_ROOT, entryPointFileName);
+    const targetFilePath = path.join(resolvedTargetDirectoryPath, entryPointFileName);
+
+    if (!(await pathExists(sourceFilePath))) {
+      continue;
+    }
+
+    if (path.resolve(sourceFilePath) === path.resolve(targetFilePath)) {
+      continue;
+    }
+
+    await ensureDirectory(path.dirname(targetFilePath));
+    await fs.copyFile(sourceFilePath, targetFilePath);
+  }
+}
+
+export async function askChoice(promptMessage, options, userInterface) {
+  console.log(`\n${promptMessage}`);
+  options.forEach((choiceLabel, choiceIndex) => {
+    console.log(`  ${choiceIndex + 1}. ${choiceLabel}`);
+  });
+
+  while (true) {
+    const selectedRawInput = await userInterface.question('Choose a number: ');
+    const selectedIndex = Number.parseInt(selectedRawInput.trim(), 10) - 1;
+
+    if (Number.isNaN(selectedIndex) || selectedIndex < 0 || selectedIndex >= options.length) {
+      console.log('Invalid choice. Please select a valid number.');
+      continue;
+    }
+
+    return options[selectedIndex];
+  }
+}
+
+export async function askYesNo(promptMessage, userInterface, defaultValue) {
+  const suffix = typeof defaultValue === 'boolean'
+    ? defaultValue ? ' (Y/n): ' : ' (y/N): '
+    : ' (y/n): ';
+
+  while (true) {
+    const answer = await userInterface.question(`\n${promptMessage}${suffix}`);
+    const normalizedAnswer = answer.trim().toLowerCase();
+
+    if (!normalizedAnswer && typeof defaultValue === 'boolean') {
+      return defaultValue;
+    }
+
+    if (normalizedAnswer === 'y' || normalizedAnswer === 'yes') return true;
+    if (normalizedAnswer === 'n' || normalizedAnswer === 'no') return false;
+
+    console.log("Please answer with 'y' or 'n'.");
+  }
+}
+
+export function toTitleCase(fileName) {
+  return fileName
+    .replace(/\.md$/i, '')
+    .split(/[-_]/g)
+    .map((wordPart) => wordPart.charAt(0).toUpperCase() + wordPart.slice(1))
+    .join(' ');
+}
+
+export function normalizeChoiceInput(rawInput) {
+  return rawInput.trim().toLowerCase().replace(/\s+/g, '-');
+}
+
+export function matchFileNameFromInput(rawInput, fileNames) {
+  const normalizedInput = normalizeChoiceInput(rawInput);
+
+  return fileNames.find((fileName) => {
+    const normalizedFileName = normalizeChoiceInput(fileName.replace(/\.md$/i, ''));
+    const normalizedTitle = normalizeChoiceInput(toTitleCase(fileName));
+    return normalizedInput === normalizedFileName || normalizedInput === normalizedTitle;
+  });
+}
+
+export function matchProfileNameFromInput(rawInput) {
+  const normalizedInput = normalizeChoiceInput(rawInput);
+  return Object.keys(PROFILE_PRESETS).find((profileName) => profileName === normalizedInput) || null;
+}
+
+export function parseBooleanSetting(rawBooleanValue, contextLabel) {
+  const normalizedValue = normalizeChoiceInput(rawBooleanValue);
+
+  if (normalizedValue === 'true') {
+    return true;
+  }
+
+  if (normalizedValue === 'false') {
+    return false;
+  }
+
+  throw new Error(`Invalid boolean value for ${contextLabel}: ${rawBooleanValue}`);
+}
+
+export function parseBlockingSeverities(rawSeverityValues, fileName) {
+  const parsedSeverities = rawSeverityValues
+    .split(',')
+    .map((severityValue) => normalizeChoiceInput(severityValue))
+    .filter(Boolean);
+
+  if (parsedSeverities.length === 0) {
+    throw new Error(`Profile pack ${fileName} must define at least one blocking severity.`);
+  }
+
+  const invalidSeverity = parsedSeverities.find((severityValue) => !ALLOWED_SEVERITY_LEVELS.has(severityValue));
+  if (invalidSeverity) {
+    throw new Error(`Profile pack ${fileName} uses unsupported severity: ${invalidSeverity}`);
+  }
+
+  return parsedSeverities;
+}
+
+export async function collectFileNames(folderPath) {
+  const fileNames = await fs.readdir(folderPath, { withFileTypes: true });
+  return fileNames
+    .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
+    .map((entry) => entry.name)
+    .sort((leftName, rightName) => leftName.localeCompare(rightName));
+}
+
+export function formatBlockingSeverities(blockingSeverities) {
+  return blockingSeverities.join(', ');
+}
+
+export function formatDuration(durationMs) {
+  const durationInSeconds = (durationMs / 1000).toFixed(1);
+  return `${durationInSeconds}s`;
+}

package/mcp.json

@@ -1,92 +1,92 @@
-{
-  "$schema": "https://modelcontextprotocol.io/schemas/mcp.json",
-  "version": "1.0",
-  "name": "agentic-senior-core",
-  "description": "MCP configuration for governance-aware diagnostics and self-healing workflows with full knowledge injection.",
-  "knowledgeLayers": {
-    "enabled": true,
-    "description": "8-layer unified knowledge injection for AI agents",
-    "layers": {
-      "rules": {
-        "path": ".agent-context/rules",
-        "count": 14,
-        "autoLoad": true
-      },
-      "stacks": {
-        "path": ".agent-context/stacks",
-        "count": 10,
-        "autoLoad": true
-      },
-      "blueprints": {
-        "path": ".agent-context/blueprints",
-        "count": 14,
-        "autoLoad": true
-      },
-      "skills": {
-        "path": ".agent-context/skills",
-        "count": 6,
-        "autoLoad": true,
-        "packs": ["backend", "frontend", "cli", "distribution", "fullstack", "review-quality"]
-      },
-      "prompts": {
-        "path": ".agent-context/prompts",
-        "count": 3,
-        "autoLoad": true,
-        "templates": ["init-project", "refactor", "review-code"]
-      },
-      "profiles": {
-        "path": ".agent-context/profiles",
-        "count": 3,
-        "autoLoad": true,
-        "governance": ["platform", "regulated", "startup"]
-      },
-      "state": {
-        "path": ".agent-context/state",
-        "count": 6,
-        "autoLoad": true
-      },
-      "policies": {
-        "path": ".agent-context/policies",
-        "count": 1,
-        "autoLoad": true
-      }
-    }
-  },
-  "servers": {
-    "lint": {
-      "command": "node",
-      "args": ["./scripts/validate.mjs"],
-      "transport": "stdio"
-    },
-    "test": {
-      "command": "node",
-      "args": ["--test", "./tests/cli-smoke.test.mjs", "./tests/llm-judge.test.mjs"],
-      "transport": "stdio"
-    }
-  },
-  "workflows": {
-    "self-heal-on-failure": {
-      "trigger": ["ci.failure", "lint.failure"],
-      "steps": [
-        "collect_logs",
-        "map_violation_to_rule",
-        "propose_patch",
-        "run_checklist_review"
-      ]
-    },
-    "full-knowledge-injection": {
-      "trigger": ["workspace.initialize", "agent.start"],
-      "steps": [
-        "load_all_knowledge_layers",
-        "inject_rules",
-        "inject_stacks",
-        "inject_blueprints",
-        "inject_skills",
-        "inject_prompts",
-        "inject_profiles",
-        "inject_state",
-        "inject_policies"
-      ]
-    }
-  }
-}
+{
+  "$schema": "https://modelcontextprotocol.io/schemas/mcp.json",
+  "version": "1.0",
+  "name": "agentic-senior-core",
+  "description": "MCP configuration for governance-aware diagnostics and self-healing workflows with full knowledge injection.",
+  "knowledgeLayers": {
+    "enabled": true,
+    "description": "8-layer unified knowledge injection for AI agents",
+    "layers": {
+      "rules": {
+        "path": ".agent-context/rules",
+        "count": 14,
+        "autoLoad": true
+      },
+      "stacks": {
+        "path": ".agent-context/stacks",
+        "count": 10,
+        "autoLoad": true
+      },
+      "blueprints": {
+        "path": ".agent-context/blueprints",
+        "count": 14,
+        "autoLoad": true
+      },
+      "skills": {
+        "path": ".agent-context/skills",
+        "count": 6,
+        "autoLoad": true,
+        "packs": ["backend", "frontend", "cli", "distribution", "fullstack", "review-quality"]
+      },
+      "prompts": {
+        "path": ".agent-context/prompts",
+        "count": 3,
+        "autoLoad": true,
+        "templates": ["init-project", "refactor", "review-code"]
+      },
+      "profiles": {
+        "path": ".agent-context/profiles",
+        "count": 3,
+        "autoLoad": true,
+        "governance": ["platform", "regulated", "startup"]
+      },
+      "state": {
+        "path": ".agent-context/state",
+        "count": 6,
+        "autoLoad": true
+      },
+      "policies": {
+        "path": ".agent-context/policies",
+        "count": 1,
+        "autoLoad": true
+      }
+    }
+  },
+  "servers": {
+    "lint": {
+      "command": "node",
+      "args": ["./scripts/validate.mjs"],
+      "transport": "stdio"
+    },
+    "test": {
+      "command": "node",
+      "args": ["--test", "./tests/cli-smoke.test.mjs", "./tests/llm-judge.test.mjs"],
+      "transport": "stdio"
+    }
+  },
+  "workflows": {
+    "self-heal-on-failure": {
+      "trigger": ["ci.failure", "lint.failure"],
+      "steps": [
+        "collect_logs",
+        "map_violation_to_rule",
+        "propose_patch",
+        "run_checklist_review"
+      ]
+    },
+    "full-knowledge-injection": {
+      "trigger": ["workspace.initialize", "agent.start"],
+      "steps": [
+        "load_all_knowledge_layers",
+        "inject_rules",
+        "inject_stacks",
+        "inject_blueprints",
+        "inject_skills",
+        "inject_prompts",
+        "inject_profiles",
+        "inject_state",
+        "inject_policies"
+      ]
+    }
+  }
+}

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@ryuenn3123/agentic-senior-core",
-  "version": "1.9.0",
+  "version": "1.9.2",
+  "type": "module",
   "description": "Force your AI Agent to code like a Staff Engineer, not a Junior.",
   "bin": {
     "agentic-senior-core": "bin/agentic-senior-core.js"
   },
   "files": [
     "bin/",
+    "lib/",
     "scripts/",
     ".agent-context/",
     ".agents/",