@ryuenn3123/agentic-senior-core 2.0.25 → 2.0.27

package/lib/cli/compiler.mjs

@@ -9,6 +9,7 @@ import {
   CLI_VERSION,
   POLICY_FILE_NAME,
   SKILL_PLATFORM_INDEX_PATH,
+  BLUEPRINT_RECOMMENDATIONS,
 } from './constants.mjs';
 
 import {
@@ -38,12 +39,15 @@ export async function writeOnboardingReport({
   selectedProfilePack,
   selectedPreset,
   selectedStackFileName,
+  selectedAdditionalStackFileNames = [],
   selectedBlueprintFileName,
+  selectedAdditionalBlueprintFileNames = [],
   includeCiGuardrails,
   setupDurationMs,
   projectDetection,
   selectedSkillDomains = [],
   compatibilityWarnings = [],
+  runtimeEnvironment = null,
   operationMode = 'init',
 }) {
   const onboardingReportPath = path.join(targetDirectoryPath, '.agent-context', 'state', 'onboarding-report.json');
@@ -60,14 +64,23 @@ export async function writeOnboardingReport({
       : null,
     selectedPreset,
     selectedStack: selectedStackFileName,
+    selectedAdditionalStacks: selectedAdditionalStackFileNames,
     selectedBlueprint: selectedBlueprintFileName,
+    selectedAdditionalBlueprints: selectedAdditionalBlueprintFileNames,
     ciGuardrailsEnabled: includeCiGuardrails,
     setupDurationMs,
     selectedSkillDomains,
     compatibilityWarnings,
+    runtimeEnvironment,
     autoDetection: {
       recommendedStack: projectDetection.recommendedStackFileName,
+      recommendedAdditionalStacks: projectDetection.secondaryStackFileNames || [],
       recommendedBlueprint: projectDetection.recommendedBlueprintFileName,
+      recommendedAdditionalBlueprints: Array.isArray(projectDetection.secondaryStackFileNames)
+        ? projectDetection.secondaryStackFileNames
+          .map((secondaryStackFileName) => BLUEPRINT_RECOMMENDATIONS[secondaryStackFileName] || null)
+          .filter(Boolean)
+        : [],
       confidenceLabel: projectDetection.confidenceLabel,
       confidenceScore: projectDetection.confidenceScore,
       confidenceGap: projectDetection.confidenceGap,
@@ -94,7 +107,9 @@ export async function buildCompiledRulesContent({
   targetDirectoryPath,
   selectedProfileName,
   selectedStackFileName,
+  selectedAdditionalStackFileNames = [],
   selectedBlueprintFileName,
+  selectedAdditionalBlueprintFileNames = [],
   includeCiGuardrails,
 }) {
   const resolvedTargetDirectoryPath = path.resolve(targetDirectoryPath);
@@ -102,7 +117,20 @@ export async function buildCompiledRulesContent({
   const selectedStacksDirectoryPath = path.join(resolvedTargetDirectoryPath, '.agent-context', 'stacks');
   const selectedBlueprintsDirectoryPath = path.join(resolvedTargetDirectoryPath, '.agent-context', 'blueprints');
   const skillPlatformIndex = JSON.parse(await fs.readFile(SKILL_PLATFORM_INDEX_PATH, 'utf8'));
-  const selectedSkillDomainNames = inferSkillDomainNamesFromSelection(selectedStackFileName, selectedBlueprintFileName);
+  const normalizedAdditionalStackFileNames = Array.isArray(selectedAdditionalStackFileNames)
+    ? Array.from(new Set(selectedAdditionalStackFileNames.filter((stackFileName) => stackFileName && stackFileName !== selectedStackFileName)))
+    : [];
+  const normalizedAdditionalBlueprintFileNames = Array.isArray(selectedAdditionalBlueprintFileNames)
+    ? Array.from(new Set(selectedAdditionalBlueprintFileNames.filter(
+      (blueprintFileName) => blueprintFileName && blueprintFileName !== selectedBlueprintFileName
+    )))
+    : [];
+  const selectedSkillDomainNames = inferSkillDomainNamesFromSelection(
+    selectedStackFileName,
+    selectedBlueprintFileName,
+    normalizedAdditionalStackFileNames,
+    normalizedAdditionalBlueprintFileNames
+  );
 
   const universalRuleFileNames = await collectFileNames(selectedRulesDirectoryPath);
   const contextBlocks = [];
@@ -166,6 +194,16 @@ export async function buildCompiledRulesContent({
     ].join('\n')
   );
 
+  if (normalizedAdditionalStackFileNames.length > 0) {
+    contextBlocks.push(
+      [
+        '## LAYER 2B: ADDITIONAL STACK PROFILES',
+        'This project uses multiple stacks. Load all additional stack profiles below:',
+        ...normalizedAdditionalStackFileNames.map((stackFileName, stackIndex) => `${stackIndex + 1}. .agent-context/stacks/${stackFileName}`),
+      ].join('\n')
+    );
+  }
+
   const blueprintFilePath = path.join(selectedBlueprintsDirectoryPath, selectedBlueprintFileName);
   const blueprintContent = await fs.readFile(blueprintFilePath, 'utf8');
   const blueprintSummary = firstMarkdownHeading(blueprintContent, selectedBlueprintFileName);
@@ -178,6 +216,18 @@ export async function buildCompiledRulesContent({
     ].join('\n')
   );
 
+  if (normalizedAdditionalBlueprintFileNames.length > 0) {
+    contextBlocks.push(
+      [
+        '## LAYER 3A: ADDITIONAL BLUEPRINT PROFILES',
+        'This project uses multiple architecture blueprints. Load all additional blueprint profiles below:',
+        ...normalizedAdditionalBlueprintFileNames.map(
+          (blueprintFileName, blueprintIndex) => `${blueprintIndex + 1}. .agent-context/blueprints/${blueprintFileName}`
+        ),
+      ].join('\n')
+    );
+  }
+
   if (includeCiGuardrails) {
     contextBlocks.push(
       [
@@ -300,7 +350,9 @@ export async function compileDynamicContext({
   targetDirectoryPath,
   selectedProfileName,
   selectedStackFileName,
+  selectedAdditionalStackFileNames = [],
   selectedBlueprintFileName,
+  selectedAdditionalBlueprintFileNames = [],
   includeCiGuardrails,
 }) {
   const resolvedTargetDirectoryPath = path.resolve(targetDirectoryPath);
@@ -308,7 +360,9 @@ export async function compileDynamicContext({
     targetDirectoryPath: resolvedTargetDirectoryPath,
     selectedProfileName,
     selectedStackFileName,
+    selectedAdditionalStackFileNames,
     selectedBlueprintFileName,
+    selectedAdditionalBlueprintFileNames,
     includeCiGuardrails,
   });
 

package/lib/cli/constants.mjs

@@ -160,6 +160,89 @@ export const PROFILE_PRESETS = {
   },
 };
 
+export const PROJECT_SCOPE_CHOICES = [
+  {
+    key: 'api-service',
+    label: 'API service',
+  },
+  {
+    key: 'web-application',
+    label: 'Web application',
+  },
+  {
+    key: 'mobile-app',
+    label: 'Mobile app',
+  },
+  {
+    key: 'cli-tool',
+    label: 'CLI tool',
+  },
+  {
+    key: 'library-sdk',
+    label: 'Library / SDK',
+  },
+  {
+    key: 'other',
+    label: 'Other',
+  },
+];
+
+export const PROJECT_SCOPE_STACK_FILTERS = {
+  'api-service': ['typescript.md', 'python.md', 'go.md', 'java.md', 'php.md', 'csharp.md', 'ruby.md', 'rust.md'],
+  'web-application': ['typescript.md', 'python.md', 'go.md', 'java.md', 'php.md', 'csharp.md', 'ruby.md', 'rust.md'],
+  'mobile-app': ['react-native.md', 'flutter.md'],
+  'cli-tool': ['typescript.md', 'python.md', 'go.md', 'rust.md', 'ruby.md', 'java.md', 'csharp.md'],
+  'library-sdk': ['typescript.md', 'python.md', 'go.md', 'rust.md', 'java.md', 'csharp.md', 'php.md', 'ruby.md'],
+  other: null,
+};
+
+export const WEB_FRONTEND_STACK_CANDIDATES = ['typescript.md'];
+
+export const WEB_BACKEND_STACK_CANDIDATES = [
+  'typescript.md',
+  'python.md',
+  'go.md',
+  'java.md',
+  'php.md',
+  'csharp.md',
+  'ruby.md',
+  'rust.md',
+];
+
+export const WEB_FRONTEND_BLUEPRINT_CANDIDATES = [
+  'api-nextjs.md',
+];
+
+export const WEB_BACKEND_BLUEPRINT_CANDIDATES = [
+  'nestjs-logic.md',
+  'fastapi-service.md',
+  'go-service.md',
+  'spring-boot-api.md',
+  'laravel-api.md',
+  'aspnet-api.md',
+  'graphql-grpc-api.md',
+  'api-nextjs.md',
+];
+
+export const RUNTIME_ENVIRONMENT_CHOICES = [
+  {
+    key: 'linux-wsl',
+    label: 'Linux / WSL',
+  },
+  {
+    key: 'windows',
+    label: 'Windows',
+  },
+  {
+    key: 'linux',
+    label: 'Linux',
+  },
+  {
+    key: 'macos',
+    label: 'macOS',
+  },
+];
+
 export const entryPointFiles = [
   '.cursorrules',
   '.windsurfrules',

package/lib/cli/detector.mjs

@@ -133,6 +133,7 @@ export async function detectProjectContext(targetDirectoryPath) {
     return {
       hasExistingProjectFiles,
       recommendedStackFileName: null,
+      secondaryStackFileNames: [],
       recommendedBlueprintFileName: null,
       confidenceLabel: null,
       confidenceScore: 0,
@@ -164,6 +165,10 @@ export async function detectProjectContext(targetDirectoryPath) {
     confidenceScore: Number(detectionCandidate.confidenceScore.toFixed(2)),
     evidence: detectionCandidate.evidence,
   }));
+  const secondaryStackFileNames = rankedCandidates
+    .slice(1)
+    .filter((rankedCandidate) => (strongestCandidate.confidenceScore - rankedCandidate.confidenceScore) < 0.08)
+    .map((rankedCandidate) => rankedCandidate.stackFileName);
   const detectionReasoning = isAmbiguous
     ? `Top signal ${toTitleCase(strongestCandidate.stackFileName)} is close to ${toTitleCase(secondStrongestCandidate.stackFileName)} (confidence gap ${confidenceGap}).`
     : `Top signal ${toTitleCase(strongestCandidate.stackFileName)} won with confidence ${strongestCandidate.confidenceScore.toFixed(2)} from markers: ${strongestCandidate.evidence.join(', ') || 'none'}.`;
@@ -171,6 +176,7 @@ export async function detectProjectContext(targetDirectoryPath) {
   return {
     hasExistingProjectFiles,
     recommendedStackFileName: strongestCandidate.stackFileName,
+    secondaryStackFileNames,
     recommendedBlueprintFileName: BLUEPRINT_RECOMMENDATIONS[strongestCandidate.stackFileName] || null,
     confidenceLabel,
     confidenceScore: strongestCandidate.confidenceScore,
@@ -194,7 +200,11 @@ export function buildDetectionSummary(projectDetection) {
     ? ` Confidence gap: ${projectDetection.confidenceGap}.`
     : '';
 
-  return `This folder looks like ${toTitleCase(projectDetection.recommendedStackFileName)} with ${projectDetection.confidenceLabel} confidence based on ${readableEvidence}.${confidenceGapSummary}`;
+  const secondaryStacksSummary = projectDetection.secondaryStackFileNames?.length
+    ? ` Secondary stack signals: ${projectDetection.secondaryStackFileNames.map((stackFileName) => toTitleCase(stackFileName)).join(', ')}.`
+    : '';
+
+  return `This folder looks like ${toTitleCase(projectDetection.recommendedStackFileName)} with ${projectDetection.confidenceLabel} confidence based on ${readableEvidence}.${confidenceGapSummary}${secondaryStacksSummary}`;
 }
 
 export function formatDetectionCandidates(rankedCandidates) {

package/lib/cli/memory-continuity.mjs

@@ -0,0 +1,266 @@
+/**
+ * Cross-agent memory continuity utilities.
+ * Provides provider-agnostic observation normalization, privacy redaction,
+ * lightweight indexing, and selective hydration helpers.
+ */
+
+const PRIVATE_BLOCK_PATTERN = /<private>[\s\S]*?<\/private>/gi;
+
+const INLINE_SENSITIVE_PATTERNS = [
+  {
+    reason: 'api-key-like-value',
+    pattern: /\b(api[_-]?key)\b\s*[:=]\s*[^\s,;]+/gi,
+    replacer: (_match, fieldName) => `${fieldName}=[REDACTED]`,
+  },
+  {
+    reason: 'token-like-value',
+    pattern: /\b(token)\b\s*[:=]\s*[^\s,;]+/gi,
+    replacer: (_match, fieldName) => `${fieldName}=[REDACTED]`,
+  },
+  {
+    reason: 'password-like-value',
+    pattern: /\b(password|passwd|pwd)\b\s*[:=]\s*[^\s,;]+/gi,
+    replacer: (_match, fieldName) => `${fieldName}=[REDACTED]`,
+  },
+  {
+    reason: 'bearer-token',
+    pattern: /\bBearer\s+[A-Za-z0-9._-]+/g,
+    replacer: () => 'Bearer [REDACTED]',
+  },
+];
+
+export const MEMORY_SCHEMA_VERSION = '1.0.0';
+
+export const SUPPORTED_MEMORY_ADAPTER_IDS = Object.freeze([
+  'claude-code',
+  'gemini-cli',
+  'vscode-chat',
+]);
+
+export const SUPPORTED_MEMORY_EVENT_TYPES = Object.freeze([
+  'prompt',
+  'tool-use',
+  'decision',
+  'summary',
+  'issue',
+  'context',
+]);
+
+function toIsoTimestamp(rawValue) {
+  if (typeof rawValue !== 'string' || rawValue.trim().length === 0) {
+    return new Date().toISOString();
+  }
+
+  const parsedDate = new Date(rawValue);
+  if (Number.isNaN(parsedDate.getTime())) {
+    return new Date().toISOString();
+  }
+
+  return parsedDate.toISOString();
+}
+
+function toNonEmptyString(rawValue, fallbackValue = '') {
+  if (typeof rawValue !== 'string') {
+    return fallbackValue;
+  }
+
+  const normalizedValue = rawValue.trim();
+  return normalizedValue.length > 0 ? normalizedValue : fallbackValue;
+}
+
+function normalizeTags(rawTags) {
+  if (!Array.isArray(rawTags)) {
+    return [];
+  }
+
+  const tagSet = new Set();
+  for (const rawTag of rawTags) {
+    const normalizedTag = toNonEmptyString(String(rawTag || '')).toLowerCase();
+    if (normalizedTag) {
+      tagSet.add(normalizedTag);
+    }
+  }
+
+  return Array.from(tagSet);
+}
+
+export function estimateTokenUsage(rawText = '') {
+  const normalizedText = String(rawText || '');
+  return Math.max(1, Math.ceil(normalizedText.length / 4));
+}
+
+export function redactSensitiveMemoryText(rawText = '') {
+  let normalizedText = String(rawText || '');
+  const redactionReasons = new Set();
+  let privateTagRedactionCount = 0;
+  let inlineRedactionCount = 0;
+
+  normalizedText = normalizedText.replace(PRIVATE_BLOCK_PATTERN, () => {
+    privateTagRedactionCount += 1;
+    redactionReasons.add('private-tag');
+    return '[REDACTED_PRIVATE_BLOCK]';
+  });
+
+  for (const sensitivePattern of INLINE_SENSITIVE_PATTERNS) {
+    normalizedText = normalizedText.replace(sensitivePattern.pattern, (...replacerArguments) => {
+      inlineRedactionCount += 1;
+      redactionReasons.add(sensitivePattern.reason);
+      return sensitivePattern.replacer(...replacerArguments);
+    });
+  }
+
+  return {
+    redactedText: normalizedText,
+    wasRedacted: privateTagRedactionCount > 0 || inlineRedactionCount > 0,
+    privateTagRedactionCount,
+    inlineRedactionCount,
+    redactionReasons: Array.from(redactionReasons),
+  };
+}
+
+export function normalizeMemoryObservation(rawObservation, options = {}) {
+  const fallbackAdapterId = options.fallbackAdapterId || 'unknown-adapter';
+  const observationId = toNonEmptyString(rawObservation?.id, `${fallbackAdapterId}-${Date.now()}`);
+  const adapterId = toNonEmptyString(rawObservation?.adapterId, fallbackAdapterId);
+
+  const eventTypeCandidate = toNonEmptyString(rawObservation?.eventType, 'context').toLowerCase();
+  const eventType = SUPPORTED_MEMORY_EVENT_TYPES.includes(eventTypeCandidate)
+    ? eventTypeCandidate
+    : 'context';
+
+  const rawDetail = toNonEmptyString(rawObservation?.detail, '');
+  const detailRedaction = redactSensitiveMemoryText(rawDetail);
+
+  const rawSummary = toNonEmptyString(rawObservation?.summary, detailRedaction.redactedText.slice(0, 220));
+  const summaryRedaction = redactSensitiveMemoryText(rawSummary);
+
+  const title = toNonEmptyString(rawObservation?.title, `${eventType} from ${adapterId}`);
+  const tags = normalizeTags(rawObservation?.tags);
+
+  return {
+    id: observationId,
+    projectId: toNonEmptyString(rawObservation?.projectId, 'default-project'),
+    sessionId: toNonEmptyString(rawObservation?.sessionId, 'default-session'),
+    adapterId,
+    eventType,
+    timestamp: toIsoTimestamp(rawObservation?.timestamp),
+    title,
+    summary: summaryRedaction.redactedText,
+    detail: detailRedaction.redactedText,
+    tags,
+    privacy: {
+      level: toNonEmptyString(rawObservation?.privacyLevel, 'internal'),
+      redactionApplied: detailRedaction.wasRedacted || summaryRedaction.wasRedacted,
+      redactionReasons: Array.from(new Set([
+        ...detailRedaction.redactionReasons,
+        ...summaryRedaction.redactionReasons,
+      ])),
+      privateTagRedactionCount: detailRedaction.privateTagRedactionCount + summaryRedaction.privateTagRedactionCount,
+      inlineRedactionCount: detailRedaction.inlineRedactionCount + summaryRedaction.inlineRedactionCount,
+    },
+  };
+}
+
+export function scoreObservationRelevance(queryText, normalizedObservation) {
+  const normalizedQuery = toNonEmptyString(queryText, '').toLowerCase();
+  if (!normalizedQuery) {
+    return 0;
+  }
+
+  const queryTerms = normalizedQuery
+    .split(/\s+/)
+    .map((queryTerm) => queryTerm.trim())
+    .filter((queryTerm) => queryTerm.length > 2);
+
+  if (queryTerms.length === 0) {
+    return 0;
+  }
+
+  const searchableContent = [
+    normalizedObservation.title,
+    normalizedObservation.summary,
+    normalizedObservation.detail,
+    normalizedObservation.tags.join(' '),
+    normalizedObservation.eventType,
+    normalizedObservation.adapterId,
+  ].join(' ').toLowerCase();
+
+  let matchCount = 0;
+  for (const queryTerm of queryTerms) {
+    if (searchableContent.includes(queryTerm)) {
+      matchCount += 1;
+    }
+  }
+
+  return Number((matchCount / queryTerms.length).toFixed(4));
+}
+
+export function buildSessionStartIndex(normalizedObservations, options = {}) {
+  const queryText = toNonEmptyString(options.queryText, '');
+  const maxIndexEntries = Number.isFinite(Number(options.limit)) ? Math.max(1, Number(options.limit)) : 8;
+
+  const rankedEntries = normalizedObservations
+    .map((normalizedObservation) => {
+      const relevanceScore = scoreObservationRelevance(queryText, normalizedObservation);
+      const indexLine = `${normalizedObservation.id}|${normalizedObservation.adapterId}|${normalizedObservation.eventType}|${normalizedObservation.title}`;
+      const indexTokenEstimate = estimateTokenUsage(indexLine);
+
+      return {
+        id: normalizedObservation.id,
+        adapterId: normalizedObservation.adapterId,
+        eventType: normalizedObservation.eventType,
+        timestamp: normalizedObservation.timestamp,
+        title: normalizedObservation.title,
+        summarySnippet: normalizedObservation.summary.slice(0, 120),
+        tags: normalizedObservation.tags,
+        relevanceScore,
+        indexTokenEstimate,
+      };
+    })
+    .sort((leftEntry, rightEntry) => {
+      if (rightEntry.relevanceScore !== leftEntry.relevanceScore) {
+        return rightEntry.relevanceScore - leftEntry.relevanceScore;
+      }
+
+      return rightEntry.timestamp.localeCompare(leftEntry.timestamp);
+    });
+
+  const indexEntries = rankedEntries.slice(0, maxIndexEntries);
+  const totalTokenEstimate = indexEntries.reduce(
+    (tokenAccumulator, indexEntry) => tokenAccumulator + indexEntry.indexTokenEstimate,
+    0
+  );
+
+  return {
+    indexEntries,
+    totalTokenEstimate,
+    totalCandidateCount: rankedEntries.length,
+  };
+}
+
+export function hydrateIndexedObservations(indexEntries, normalizedObservations, options = {}) {
+  const fullFetchLimit = Number.isFinite(Number(options.fullFetchLimit))
+    ? Math.max(1, Number(options.fullFetchLimit))
+    : 2;
+
+  const observationLookup = new Map(normalizedObservations.map((normalizedObservation) => [
+    normalizedObservation.id,
+    normalizedObservation,
+  ]));
+
+  const selectedIds = indexEntries.slice(0, fullFetchLimit).map((indexEntry) => indexEntry.id);
+  const hydratedObservations = selectedIds
+    .map((selectedId) => observationLookup.get(selectedId))
+    .filter(Boolean);
+
+  const hydrationTokenEstimate = hydratedObservations.reduce(
+    (tokenAccumulator, hydratedObservation) => tokenAccumulator + estimateTokenUsage(hydratedObservation.detail),
+    0
+  );
+
+  return {
+    selectedIds,
+    hydratedObservations,
+    hydrationTokenEstimate,
+  };
+}