@ryuenn3123/agentic-senior-core 4.4.0 → 5.2.0

package/lib/cli/adaptive-context/catalog.mjs

@@ -1,394 +0,0 @@
-export const RULE_FAMILY_CATALOG = [
-  {
-    label: 'SEC',
-    rulePath: '.agent-context/rules/security.md',
-    priority: 10,
-    triggers: [
-      'auth',
-      'authorization',
-      'login',
-      'password',
-      'permission',
-      'role',
-      'secret',
-      'secrets',
-      'session',
-      'turnstile',
-      'jwt',
-      'csrf',
-      'xss',
-      'sql injection',
-      'request validation',
-      'safe request',
-      'access',
-      'akses',
-      'kebuka',
-      'expose',
-      'exposed',
-      'exposing',
-      'credential',
-      'credentials',
-      'access token',
-      'api token',
-      'auth token',
-      'bearer token',
-      'tenant',
-      'tenant sebelah',
-      'user lain',
-    ],
-  },
-  {
-    label: 'API',
-    rulePath: '.agent-context/rules/api-docs.md',
-    priority: 20,
-    triggers: [
-      'api',
-      'endpoint',
-      'route',
-      'response',
-      'http',
-      'webhook',
-      'contract',
-      'pagination',
-      'cli',
-      'command',
-      'idempotent',
-      'idempotency',
-      'documented',
-      'diagram',
-      'mermaid',
-    ],
-  },
-  {
-    label: 'ERR',
-    rulePath: '.agent-context/rules/error-handling.md',
-    priority: 30,
-    triggers: [
-      'error',
-      'errors',
-      'exception',
-      'fail',
-      'failed',
-      'failing',
-      'bug',
-      'crash',
-      'stack trace',
-      'null',
-      'undefined',
-      'rollback',
-      'debug',
-      'gagal',
-      'fix',
-      'broke',
-      'broken',
-      'stops',
-      'stopped',
-      'bermasalah',
-      'ga jalan',
-      'nggak jalan',
-      'tidak jalan',
-    ],
-  },
-  {
-    label: 'TEST',
-    rulePath: '.agent-context/rules/testing.md',
-    priority: 40,
-    triggers: [
-      'test',
-      'tests',
-      'testing',
-      'spec',
-      'assert',
-      'assertion',
-      'coverage',
-      'validate',
-      'validation',
-      'smoke',
-      'unit',
-      'integration',
-      'benchmark',
-      'fixture',
-      'fixtures',
-      'regression',
-      'corpus',
-    ],
-  },
-  {
-    label: 'ARCH',
-    rulePath: '.agent-context/rules/architecture.md',
-    priority: 50,
-    triggers: [
-      'architecture',
-      'boundary',
-      'layer',
-      'module',
-      'structure',
-      'refactor',
-      'clean up',
-      'cleanup',
-      'over-engineer',
-      'over engineering',
-      'abstraction',
-      'helper',
-      'natural implementation',
-      'adaptive context',
-      'classifier',
-      'resolver',
-      'routing',
-      'runtime',
-      'duplicate',
-      'duplicate code',
-      'middleware',
-      'rapihin',
-      'rapikan',
-      'simple',
-      'simplicity',
-      'modularity',
-      'elegance',
-    ],
-  },
-  {
-    label: 'FE',
-    rulePath: '.agent-context/rules/frontend-architecture.md',
-    priority: 70,
-    triggers: [
-      'ui',
-      'ux',
-      'frontend',
-      'component',
-      'screen',
-      'layout',
-      'responsive',
-      'tailwind',
-      'redesign',
-      'redesain',
-      'animation',
-      'motion',
-      'page',
-      'mobile',
-      'overlap',
-      'overlaps',
-      'flicker',
-      'flickers',
-      'text overlaps',
-      'button',
-      'layar',
-      'layar kecil',
-      'kepotong',
-      'terpotong',
-    ],
-  },
-  {
-    label: 'DATA',
-    rulePath: '.agent-context/rules/database-design.md',
-    priority: 80,
-    triggers: [
-      'database',
-      'schema',
-      'sql',
-      'query',
-      'table',
-      'prisma',
-      'model',
-      'persistence',
-      'index',
-      'n+1',
-    ],
-  },
-  {
-    label: 'MIG',
-    rulePath: '.agent-context/rules/migrations.md',
-    priority: 90,
-    triggers: [
-      'migration',
-      'migrate',
-      'rollback',
-      'backfill',
-      'schema change',
-      'expand contract',
-    ],
-  },
-  {
-    label: 'PERF',
-    rulePath: '.agent-context/rules/performance.md',
-    priority: 100,
-    triggers: [
-      'performance',
-      'slow',
-      'latency',
-      'memory',
-      'n+1',
-      'cache',
-      'optimization',
-      'throughput',
-      'lemot',
-      'lambat',
-      'bottleneck',
-    ],
-  },
-  {
-    label: 'DOCK',
-    rulePath: '.agent-context/rules/docker-runtime.md',
-    priority: 110,
-    triggers: [
-      'docker',
-      'compose',
-      'container',
-      'dockerfile',
-      'image',
-    ],
-  },
-  {
-    label: 'OBS',
-    rulePath: '.agent-context/rules/observability.md',
-    priority: 120,
-    triggers: [
-      'log',
-      'logging',
-      'metric',
-      'trace',
-      'tracing',
-      'alert',
-      'observability',
-      'monitoring',
-      'slo',
-      'logs',
-      'silent',
-      'silently',
-    ],
-  },
-  {
-    label: 'RES',
-    rulePath: '.agent-context/rules/resilience.md',
-    priority: 130,
-    triggers: [
-      'retry',
-      'timeout',
-      'fallback',
-      'circuit',
-      'degraded',
-      'resilience',
-      'unavailable',
-      'recovery',
-      'offline',
-    ],
-  },
-  {
-    label: 'CFG',
-    rulePath: '.agent-context/rules/config-and-flags.md',
-    priority: 140,
-    triggers: [
-      'env',
-      'config',
-      'configuration',
-      'flag',
-      'feature flag',
-      'setting',
-      'settings',
-      'secret',
-      'key',
-      'env var',
-    ],
-  },
-  {
-    label: 'JOB',
-    rulePath: '.agent-context/rules/background-jobs.md',
-    priority: 150,
-    triggers: [
-      'queue',
-      'worker',
-      'cron',
-      'job',
-      'background',
-      'scheduler',
-    ],
-  },
-  {
-    label: 'EVT',
-    rulePath: '.agent-context/rules/event-driven.md',
-    priority: 160,
-    triggers: [
-      'event',
-      'events',
-      'message',
-      'pubsub',
-      'kafka',
-      'broker',
-      'outbox',
-      'subscriber',
-      'producer',
-    ],
-  },
-  {
-    label: 'SVC',
-    rulePath: '.agent-context/rules/microservices.md',
-    priority: 170,
-    triggers: [
-      'microservice',
-      'microservices',
-      'distributed',
-      'service split',
-      'multi-service',
-    ],
-  },
-  {
-    label: 'RT',
-    rulePath: '.agent-context/rules/realtime.md',
-    priority: 180,
-    triggers: [
-      'realtime',
-      'real-time',
-      'websocket',
-      'sse',
-      'socket',
-      'stream',
-      'live update',
-    ],
-  },
-  {
-    label: 'VER',
-    rulePath: '.agent-context/rules/api-versioning.md',
-    priority: 190,
-    triggers: [
-      'version',
-      'versioned',
-      'versioning',
-      'deprecate',
-      'deprecation',
-      'backward compatible',
-      'breaking change',
-    ],
-  },
-];
-
-export const PROMPT_CATALOG = [
-  {
-    promptPath: '.agent-context/prompts/review-code.md',
-    triggers: ['review', 'audit', 'check', 'analyze', 'analisa', 'cek'],
-  },
-  {
-    promptPath: '.agent-context/prompts/refactor.md',
-    triggers: ['refactor', 'improve', 'fix', 'clean up', 'cleanup', 'rapikan', 'perbaiki'],
-  },
-  {
-    promptPath: '.agent-context/prompts/init-project.md',
-    triggers: ['create', 'build', 'new project', 'scaffold', 'fresh project', 'bikin project'],
-  },
-  {
-    promptPath: '.agent-context/prompts/bootstrap-design.md',
-    labels: ['FE'],
-    triggers: ['ui', 'ux', 'frontend', 'layout', 'screen', 'redesign', 'redesain', 'ulang dari 0', 'research ulang'],
-  },
-];
-
-export const DOCS_BY_LABEL = {
-  ARCH: ['docs/architecture-decision-record.md', 'docs/flow-overview.md'],
-  API: ['docs/api-contract.md'],
-  DATA: ['docs/database-schema.md'],
-  FE: ['docs/DESIGN.md'],
-  TEST: ['docs/flow-overview.md'],
-};
-
-export const STATE_BY_LABEL = {
-  ARCH: ['.agent-context/state/architecture-map.md'],
-};

package/lib/cli/adaptive-context/file-signals.mjs

@@ -1,100 +0,0 @@
-export const CONTEXT_FILE_CATALOG = [
-  {
-    label: 'SEC',
-    patterns: [
-      /(^|\/)(auth|login|session|permission|permissions|role|roles|acl|policy|guard|middleware)(\.|\/|-|$)/iu,
-      /(^|\/)\.env(\.|$)/iu,
-    ],
-  },
-  {
-    label: 'API',
-    patterns: [
-      /(^|\/)(api|apis|route|routes|controller|controllers|contract|openapi)(\.|\/|-|$)/iu,
-      /(^|\/)(commands?|cli)(\.|\/|-|$)/iu,
-    ],
-  },
-  {
-    label: 'ERR',
-    patterns: [
-      /(^|\/)(errors?|exceptions?|failures?)(\.|\/|-|$)/iu,
-    ],
-  },
-  {
-    label: 'TEST',
-    patterns: [
-      /(^|\/)(tests?|__tests__)(\/|$)/iu,
-      /\.(test|spec)\.[cm]?[jt]sx?$/iu,
-    ],
-  },
-  {
-    label: 'FE',
-    patterns: [
-      /\.(tsx|jsx|vue|svelte|css|scss|sass)$/iu,
-      /(^|\/)(app|pages|screens|components?|layouts?|styles?)(\/|$)/iu,
-      /(^|\/)page\.[cm]?[jt]sx?$/iu,
-    ],
-  },
-  {
-    label: 'DATA',
-    patterns: [
-      /\.(sql|prisma)$/iu,
-      /(^|\/)(schema|schemas|models?|repositories?|db|database)(\.|\/|-|$)/iu,
-    ],
-  },
-  {
-    label: 'MIG',
-    patterns: [
-      /(^|\/)(migrations?|migration)(\/|\.|-|$)/iu,
-    ],
-  },
-  {
-    label: 'PERF',
-    patterns: [
-      /(^|\/)(performance|perf|benchmark|benchmarks)(\.|\/|-|$)/iu,
-    ],
-  },
-  {
-    label: 'DOCK',
-    patterns: [
-      /(^|\/)(dockerfile|compose\.ya?ml|docker-compose\.ya?ml)$/iu,
-      /(^|\/)\.dockerignore$/iu,
-    ],
-  },
-  {
-    label: 'OBS',
-    patterns: [
-      /(^|\/)(logging|logger|metrics?|tracing|telemetry|observability)(\.|\/|-|$)/iu,
-    ],
-  },
-  {
-    label: 'RES',
-    patterns: [
-      /(^|\/)(retry|retries|timeout|fallback|resilience|recovery)(\.|\/|-|$)/iu,
-    ],
-  },
-  {
-    label: 'CFG',
-    patterns: [
-      /(^|\/)(config|configs|settings|flags?)(\.|\/|-|$)/iu,
-      /(^|\/)\.env(\.|$)/iu,
-    ],
-  },
-  {
-    label: 'JOB',
-    patterns: [
-      /(^|\/)(jobs?|workers?|queues?|cron|scheduler)(\.|\/|-|$)/iu,
-    ],
-  },
-  {
-    label: 'EVT',
-    patterns: [
-      /(^|\/)(events?|messages?|pubsub|outbox|subscribers?|producers?)(\.|\/|-|$)/iu,
-    ],
-  },
-  {
-    label: 'RT',
-    patterns: [
-      /(^|\/)(websocket|sse|realtime|stream|socket)(\.|\/|-|$)/iu,
-    ],
-  },
-];

package/lib/cli/adaptive-context/implications.mjs

@@ -1,44 +0,0 @@
-export const IMPLICATION_CATALOG = [
-  {
-    label: 'ERR',
-    reason: 'migration failure language',
-    requiresAnyLabel: ['MIG'],
-    triggers: ['broke', 'broken', 'fail', 'failed', 'failing', 'gagal', 'stuck', 'stops', 'stopped', 'rollback'],
-  },
-  {
-    label: 'PERF',
-    reason: 'data access performance language',
-    requiresAnyLabel: ['DATA'],
-    triggers: ['slow', 'lemot', 'lambat', 'n+1', 'bottleneck', 'performance'],
-  },
-  {
-    label: 'SEC',
-    reason: 'configuration exposure language',
-    requiresAnyLabel: ['CFG'],
-    triggers: ['secret', 'secrets', 'key', 'token', 'credential', 'credentials', 'expose', 'exposed', 'exposing', 'leak', 'leaking'],
-  },
-  {
-    label: 'ARCH',
-    reason: 'security middleware structure language',
-    requiresAnyLabel: ['SEC'],
-    triggers: ['duplicate', 'duplicate code', 'middleware', 'refactor', 'clean up', 'cleanup', 'rapihin', 'rapikan'],
-  },
-  {
-    label: 'OBS',
-    reason: 'silent worker needs operator evidence',
-    requiresAnyLabel: ['JOB'],
-    triggers: ['log', 'logs', 'silent', 'silently', 'trace', 'monitoring'],
-  },
-  {
-    label: 'ERR',
-    reason: 'silent worker failure language',
-    requiresAnyLabel: ['JOB'],
-    triggers: ['stops', 'stopped', 'silent', 'silently', 'fail', 'failed', 'failing'],
-  },
-  {
-    label: 'TEST',
-    reason: 'runtime hardening needs regression evidence',
-    requiresAnyLabel: ['ARCH'],
-    triggers: ['stable', 'stability', 'miss', 'case', 'cases', 'benchmark', 'fixture', 'fixtures', 'regression'],
-  },
-];

package/lib/cli/adaptive-context.mjs

@@ -1,151 +0,0 @@
-import { DOCS_BY_LABEL, PROMPT_CATALOG, RULE_FAMILY_CATALOG, STATE_BY_LABEL } from './adaptive-context/catalog.mjs';
-import { CONTEXT_FILE_CATALOG } from './adaptive-context/file-signals.mjs';
-import { IMPLICATION_CATALOG } from './adaptive-context/implications.mjs';
-
-const CONTEXT_BUDGET_POLICY = Object.freeze({
-  maxRecommendedRuleCount: 5,
-  maxFallbackRuleCount: 7,
-});
-
-export function getRuleFamilyCatalog() {
-  return RULE_FAMILY_CATALOG.map((ruleFamily) => ({ ...ruleFamily }));
-}
-
-export function normalizeRequestText(requestText) {
-  return String(requestText || '').trim().toLowerCase().replace(/\s+/g, ' ');
-}
-
-function triggerMatchesRequest(text, trigger) {
-  if (!text || !trigger) return false;
-  return /^[a-z0-9 ]+$/.test(trigger)
-    ? new RegExp(`(^|[^a-z0-9])${trigger.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}([^a-z0-9]|$)`).test(text)
-    : text.includes(trigger);
-}
-
-const uniqueSorted = (arr) => Array.from(new Set(arr)).sort((a, b) => a.localeCompare(b));
-
-function resolveUncertainty(labels, evidence, text) {
-  if (!text || !labels.length) return 'high';
-  const hasSparseEvidence = evidence.some(e => (e.matchedTriggers.length + e.matchedFiles.length + e.matchedImplications.length) === 1);
-  return (labels.length >= 6 || hasSparseEvidence) ? 'medium' : 'low';
-}
-
-function buildContextBudget(labels, evidence) {
-  const selectedRuleCount = labels.length;
-  const evidenceSignalCount = evidence.reduce((sum, e) => sum + e.matchedTriggers.length + e.matchedFiles.length + e.matchedImplications.length, 0);
-  const overRecommendedRuleCount = Math.max(0, selectedRuleCount - CONTEXT_BUDGET_POLICY.maxRecommendedRuleCount);
-  const overFallbackRuleCount = Math.max(0, selectedRuleCount - CONTEXT_BUDGET_POLICY.maxFallbackRuleCount);
-  
-  let status = 'within-budget';
-  if (overFallbackRuleCount > 0) status = 'fallback-required';
-  else if (overRecommendedRuleCount > 0) status = 'wide-context';
-
-  return {
-    status,
-    selectedRuleCount,
-    evidenceSignalCount,
-    maxRecommendedRuleCount: CONTEXT_BUDGET_POLICY.maxRecommendedRuleCount,
-    maxFallbackRuleCount: CONTEXT_BUDGET_POLICY.maxFallbackRuleCount,
-    overRecommendedRuleCount,
-    overFallbackRuleCount,
-  };
-}
-
-export function buildSelectedContextManifest({ contextFiles = [], requestId = 'adhoc-request', requestText = '' } = {}) {
-  const normText = normalizeRequestText(requestText);
-  const normFiles = (Array.isArray(contextFiles) ? contextFiles : [])
-    .map(f => String(f || '').trim().replace(/\\/g, '/').replace(/\/+/g, '/').toLowerCase())
-    .filter(Boolean);
-
-  const matchedEntries = RULE_FAMILY_CATALOG.map(rule => {
-    const matchedTriggers = rule.triggers.filter(t => triggerMatchesRequest(normText, t));
-    const filePatterns = CONTEXT_FILE_CATALOG.find(c => c.label === rule.label)?.patterns || [];
-    const matchedFiles = normFiles.filter(f => filePatterns.some(p => p.test(f)));
-    return { ...rule, matchedTriggers, matchedFiles, matchedImplications: [] };
-  });
-
-  const matchedLabelSet = new Set(matchedEntries.filter(e => e.matchedTriggers.length || e.matchedFiles.length).map(e => e.label));
-
-  for (const imp of IMPLICATION_CATALOG) {
-    if (imp.requiresAnyLabel.some(l => matchedLabelSet.has(l))) {
-      const triggers = imp.triggers.filter(t => triggerMatchesRequest(normText, t));
-      if (triggers.length) {
-        const target = matchedEntries.find(e => e.label === imp.label);
-        if (target) {
-          const detail = `${imp.reason}: ${triggers.join(', ')}`;
-          if (!target.matchedImplications.includes(detail)) target.matchedImplications.push(detail);
-          matchedLabelSet.add(imp.label);
-        }
-      }
-    }
-  }
-
-  const matchedRuleEntries = matchedEntries
-    .filter(e => e.matchedTriggers.length || e.matchedFiles.length || e.matchedImplications.length)
-    .sort((a, b) => a.priority - b.priority || a.label.localeCompare(b.label));
-
-  const labels = matchedRuleEntries.map(e => e.label);
-  const evidence = matchedRuleEntries.map(({ label, matchedTriggers, matchedFiles, matchedImplications }) => ({ label, matchedTriggers, matchedFiles, matchedImplications }));
-  const uncertainty = resolveUncertainty(labels, evidence, normText);
-  const budget = buildContextBudget(labels, evidence);
-
-  const selectedRuleSet = new Set(matchedRuleEntries.map(e => e.rulePath));
-
-  const selectedPrompts = PROMPT_CATALOG
-    .filter(p => (Array.isArray(p.labels) && p.labels.some(l => labels.includes(l))) || p.triggers.some(t => triggerMatchesRequest(normText, t)))
-    .map(p => p.promptPath);
-
-  return {
-    schemaVersion: 'adaptive-context-manifest-v1',
-    requestId,
-    contextFiles: normFiles,
-    labels,
-    selectedRules: matchedRuleEntries.map(e => e.rulePath),
-    selectedPrompts: uniqueSorted(selectedPrompts),
-    selectedDocs: uniqueSorted(['docs/doc-index.md', ...labels.flatMap(l => DOCS_BY_LABEL[l] || [])]),
-    selectedState: uniqueSorted(['.agent-context/state/onboarding-report.json', ...labels.flatMap(l => STATE_BY_LABEL[l] || [])]),
-    skippedRules: RULE_FAMILY_CATALOG.map(r => r.rulePath).filter(r => !selectedRuleSet.has(r)).sort((a, b) => a.localeCompare(b)),
-    uncertainty,
-    budget,
-    fallbackRequired: uncertainty === 'high' || budget.status === 'fallback-required',
-    evidence,
-  };
-}
-
-export function evaluateAdaptiveContextFixtures(fixtures) {
-  const results = fixtures.map(fixture => {
-    const manifest = buildSelectedContextManifest({ requestId: fixture.id, requestText: fixture.requestText });
-    const reqSet = new Set(fixture.requiredLabels);
-    const allowSet = new Set(fixture.allowedLabels || fixture.requiredLabels);
-    return {
-      id: fixture.id,
-      passed: fixture.requiredLabels.every(l => manifest.labels.includes(l)),
-      missedRequiredLabels: fixture.requiredLabels.filter(l => !manifest.labels.includes(l)),
-      extraLabels: manifest.labels.filter(l => !allowSet.has(l)),
-      manifest,
-    };
-  });
-
-  const failed = results.filter(r => !r.passed);
-  const selectedRuleCounts = results.map(r => r.manifest.budget.selectedRuleCount);
-
-  return {
-    reportName: 'adaptive-context-benchmark',
-    generatedAt: new Date().toISOString(),
-    fixtureCount: results.length,
-    passed: failed.length === 0,
-    passedCount: results.length - failed.length,
-    failedCount: failed.length,
-    missedRequiredLabelCount: results.reduce((sum, r) => sum + r.missedRequiredLabels.length, 0),
-    extraLabelCount: results.reduce((sum, r) => sum + r.extraLabels.length, 0),
-    budgetSummary: {
-      maxSelectedRuleCount: Math.max(0, ...selectedRuleCounts),
-      averageSelectedRuleCount: results.length ? Number((selectedRuleCounts.reduce((a, b) => a + b, 0) / results.length).toFixed(2)) : 0,
-      overRecommendedFixtureCount: results.filter(r => r.manifest.budget.status !== 'within-budget').length,
-      fallbackFixtureCount: results.filter(r => r.manifest.fallbackRequired).length,
-      maxRecommendedRuleCount: CONTEXT_BUDGET_POLICY.maxRecommendedRuleCount,
-      maxFallbackRuleCount: CONTEXT_BUDGET_POLICY.maxFallbackRuleCount,
-    },
-    results,
-  };
-}