@ngockhoale/ukit 1.1.6

package/src/index/relatedTests.js

@@ -0,0 +1,237 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { getArtifactPath, getIndexDir, INDEX_ARTIFACTS } from './paths.js';
+
+const RELATED_TEST_RELATION_TYPES = [
+  { key: 'components', label: 'component' },
+  { key: 'composables', label: 'composable' },
+  { key: 'services', label: 'service' },
+  { key: 'stores', label: 'store' },
+  { key: 'utils', label: 'util' },
+];
+const RELATED_TEST_ARTIFACT_CACHE = new Map();
+const RELATED_TEST_LOOKUP_CACHE = new Map();
+
+export async function inferRelatedTests({
+  rootDir = process.cwd(),
+  candidateFiles = [],
+  limit = 5,
+  analogsArtifact = null,
+  relationsArtifact = null,
+} = {}) {
+  const {
+    analogsArtifact: resolvedAnalogsArtifact,
+    relationsArtifact: resolvedRelationsArtifact,
+    analogsMap,
+    relationsMap,
+  } = await loadRelatedTestArtifacts({
+    rootDir,
+    analogsArtifact,
+    relationsArtifact,
+  });
+
+  return inferRelatedTestsFromArtifacts({
+    candidateFiles,
+    limit,
+    analogsMap,
+    relationsMap,
+  });
+}
+
+export async function loadRelatedTestArtifacts({
+  rootDir = process.cwd(),
+  analogsArtifact = null,
+  relationsArtifact = null,
+} = {}) {
+  const absoluteRoot = path.resolve(rootDir);
+
+  if (!analogsArtifact && !relationsArtifact) {
+    if (!RELATED_TEST_LOOKUP_CACHE.has(absoluteRoot)) {
+      RELATED_TEST_LOOKUP_CACHE.set(
+        absoluteRoot,
+        Promise.all([
+          readArtifact(absoluteRoot, INDEX_ARTIFACTS.analogs),
+          readArtifact(absoluteRoot, INDEX_ARTIFACTS.relations),
+        ])
+          .then(([resolvedAnalogsArtifact, resolvedRelationsArtifact]) => ({
+            analogsArtifact: resolvedAnalogsArtifact,
+            relationsArtifact: resolvedRelationsArtifact,
+            ...buildRelatedTestLookups({
+              analogsArtifact: resolvedAnalogsArtifact,
+              relationsArtifact: resolvedRelationsArtifact,
+            }),
+          }))
+          .catch((error) => {
+            RELATED_TEST_LOOKUP_CACHE.delete(absoluteRoot);
+            throw error;
+          }),
+      );
+    }
+
+    return RELATED_TEST_LOOKUP_CACHE.get(absoluteRoot);
+  }
+
+  const [resolvedAnalogsArtifact, resolvedRelationsArtifact] = await Promise.all([
+    analogsArtifact ?? readArtifact(absoluteRoot, INDEX_ARTIFACTS.analogs),
+    relationsArtifact ?? readArtifact(absoluteRoot, INDEX_ARTIFACTS.relations),
+  ]);
+
+  return {
+    analogsArtifact: resolvedAnalogsArtifact,
+    relationsArtifact: resolvedRelationsArtifact,
+    ...buildRelatedTestLookups({
+      analogsArtifact: resolvedAnalogsArtifact,
+      relationsArtifact: resolvedRelationsArtifact,
+    }),
+  };
+}
+
+export function clearRelatedTestArtifactCache(rootDir = null) {
+  if (!rootDir) {
+    RELATED_TEST_ARTIFACT_CACHE.clear();
+    RELATED_TEST_LOOKUP_CACHE.clear();
+    return;
+  }
+
+  const absoluteRoot = path.resolve(rootDir);
+  const indexDir = getIndexDir(absoluteRoot);
+
+  for (const artifactPath of RELATED_TEST_ARTIFACT_CACHE.keys()) {
+    if (artifactPath.startsWith(indexDir)) {
+      RELATED_TEST_ARTIFACT_CACHE.delete(artifactPath);
+    }
+  }
+
+  RELATED_TEST_LOOKUP_CACHE.delete(absoluteRoot);
+}
+
+export function buildRelatedTestLookups({
+  analogsArtifact = { items: [] },
+  relationsArtifact = { items: [] },
+} = {}) {
+  return {
+    analogsMap: new Map((analogsArtifact.items ?? []).map((item) => [item.filePath, item.analogs ?? []])),
+    relationsMap: new Map((relationsArtifact.items ?? []).map((item) => [item.filePath, item.relations ?? {}])),
+  };
+}
+
+export function inferRelatedTestsFromArtifacts({
+  candidateFiles = [],
+  analogsMap = new Map(),
+  relationsMap = new Map(),
+  limit = 5,
+} = {}) {
+  const normalizedCandidates = [...new Set(
+    candidateFiles
+      .map((filePath) => String(filePath ?? '').trim())
+      .filter(Boolean),
+  )];
+
+  if (normalizedCandidates.length === 0) {
+    return [];
+  }
+
+  const suggestions = new Map();
+
+  for (const [candidateRank, candidateFile] of normalizedCandidates.entries()) {
+    const rankPenalty = candidateRank * 5;
+    const relations = relationsMap.get(candidateFile) ?? {};
+
+    addTestsFromSource({
+      sourceFilePath: candidateFile,
+      relationsMap,
+      suggestions,
+      score: 120 - rankPenalty,
+      reason: `direct test for ${candidateFile}`,
+    });
+
+    for (const siblingFile of (relations.siblings ?? []).slice(0, 3)) {
+      addTestsFromSource({
+        sourceFilePath: siblingFile,
+        relationsMap,
+        suggestions,
+        score: 90 - rankPenalty,
+        reason: `sibling test via ${siblingFile}`,
+      });
+    }
+
+    for (const analog of (analogsMap.get(candidateFile) ?? []).slice(0, 3)) {
+      addTestsFromSource({
+        sourceFilePath: analog.filePath,
+        relationsMap,
+        suggestions,
+        score: 80 + Math.round((Number(analog.score) || 0) * 20) - rankPenalty,
+        reason: `analog test via ${analog.filePath}${analog.reason ? `; ${analog.reason}` : ''}`,
+      });
+    }
+
+    for (const { key, label } of RELATED_TEST_RELATION_TYPES) {
+      for (const relatedFile of (relations[key] ?? []).slice(0, 2)) {
+        addTestsFromSource({
+          sourceFilePath: relatedFile,
+          relationsMap,
+          suggestions,
+          score: 60 - rankPenalty,
+          reason: `${label} test via ${relatedFile}`,
+        });
+      }
+    }
+  }
+
+  return [...suggestions.values()]
+    .sort((a, b) => b.score - a.score || a.filePath.localeCompare(b.filePath))
+    .slice(0, Math.max(limit, 0))
+    .map((suggestion) => ({
+      filePath: suggestion.filePath,
+      score: suggestion.score,
+      reason: suggestion.reasons.join('; '),
+    }));
+}
+
+async function readArtifact(rootDir, artifactName) {
+  const artifactPath = getArtifactPath(path.resolve(rootDir), artifactName);
+
+  if (!RELATED_TEST_ARTIFACT_CACHE.has(artifactPath)) {
+    RELATED_TEST_ARTIFACT_CACHE.set(
+      artifactPath,
+      fs.readFile(artifactPath, 'utf8')
+        .then((content) => JSON.parse(content))
+        .catch(() => {
+          RELATED_TEST_ARTIFACT_CACHE.delete(artifactPath);
+          return { items: [] };
+        }),
+    );
+  }
+
+  return RELATED_TEST_ARTIFACT_CACHE.get(artifactPath);
+}
+
+function addTestsFromSource({
+  sourceFilePath,
+  relationsMap,
+  suggestions,
+  score,
+  reason,
+}) {
+  if (!sourceFilePath) {
+    return;
+  }
+
+  const tests = relationsMap.get(sourceFilePath)?.tests ?? [];
+  for (const testFilePath of tests) {
+    if (!suggestions.has(testFilePath)) {
+      suggestions.set(testFilePath, {
+        filePath: testFilePath,
+        score,
+        reasons: [],
+      });
+    }
+
+    const suggestion = suggestions.get(testFilePath);
+    suggestion.score = Math.max(suggestion.score, score);
+    if (!suggestion.reasons.includes(reason)) {
+      suggestion.reasons.push(reason);
+    }
+  }
+}

package/src/index/resolveContext.js

@@ -0,0 +1,345 @@
+import { queryCodeIndex } from './queryIndex.js';
+import { inferRelatedTestsFromArtifacts, loadRelatedTestArtifacts } from './relatedTests.js';
+
+const TASK_TYPE_BUDGETS = {
+  trivial: { minFiles: 1, maxFiles: 2 },
+  simple: { minFiles: 2, maxFiles: 5 },
+  'non-trivial': { minFiles: 4, maxFiles: 8 },
+};
+
+const TRIVIAL_SIGNALS = ['typo', 'label', 'text', 'rename', 'color', 'spacing', 'toggle', 'config', 'comment'];
+const RISKY_SIGNALS = [
+  'auth', 'security', 'migration', 'uninstall', 'password', 'token', 'permission',
+  'delete all', 'drop table', 'race', 'flaky', 'intermittent', 'timeout', 'deadlock',
+  'core', 'shared', 'runtime',
+];
+const EXPANSION_SIGNALS = [
+  'similar',
+  'same as',
+  'like',
+  'pattern',
+  'clone',
+  'analog',
+  'follow',
+  'example',
+  'search',
+  'find',
+  'where',
+  'which file',
+  'across',
+  'everywhere',
+  'multiple',
+  'project',
+  'repo',
+  'workspace',
+  'all ',
+  'every ',
+];
+
+export async function resolveContext({
+  rootDir = process.cwd(),
+  intent = '',
+  targetFile = null,
+  taskType = null,
+} = {}) {
+  const classifiedType = taskType ?? classifyTask(intent);
+  const budget = TASK_TYPE_BUDGETS[classifiedType] ?? TASK_TYPE_BUDGETS.simple;
+  const queryWasUsed = shouldQueryIndex({ intent, targetFile, taskType: classifiedType });
+
+  const result = {
+    taskType: classifiedType,
+    contextBudget: { ...budget, taskType: classifiedType },
+    primaryTargets: [],
+    analogFiles: [],
+    sharedAbstractions: [],
+    relatedTests: [],
+    styleFiles: [],
+    explanations: {
+      primaryTargets: [],
+      analogFiles: [],
+      sharedAbstractions: [],
+      relatedTests: [],
+      styleFiles: [],
+    },
+  };
+
+  // Step 1: Find primary targets
+  if (targetFile) {
+    addExplainedFile(result, 'primaryTargets', targetFile, 'explicit target');
+  }
+
+  if (queryWasUsed) {
+    const queryResults = await queryCodeIndex({ rootDir, query: intent, limit: budget.maxFiles });
+    for (const qr of queryResults) {
+      addExplainedFile(result, 'primaryTargets', qr.filePath, buildQueryReason(qr));
+    }
+  }
+
+  if (result.primaryTargets.length === 0) {
+    return result;
+  }
+
+  const { relationsArtifact, relationsMap } = await loadRelatedTestArtifacts({
+    rootDir,
+    analogsArtifact: { items: [] },
+  });
+
+  // Step 2: Get relations for primary targets to find shared abstractions
+  for (const primary of result.primaryTargets) {
+    const rels = relationsMap.get(primary) ?? {};
+
+    // Related tests
+    for (const testPath of rels.tests ?? []) {
+      addExplainedFile(result, 'relatedTests', testPath, `test linked to ${primary}`);
+    }
+
+    for (const stylePath of rels.styles ?? []) {
+      addExplainedFile(result, 'styleFiles', stylePath, `style imported by ${primary}`);
+    }
+  }
+
+  const preferLocalizedDirectContext = shouldPreferLocalizedDirectTargetContext({
+    result,
+    taskType: classifiedType,
+    targetFile,
+    queryWasUsed,
+  });
+
+  if (!preferLocalizedDirectContext) {
+    for (const primary of result.primaryTargets) {
+      const rels = relationsMap.get(primary) ?? {};
+
+      for (const absType of ['composables', 'utils', 'services']) {
+        for (const absPath of rels[absType] ?? []) {
+          if (result.primaryTargets.includes(absPath)) {
+            continue;
+          }
+          addExplainedFile(result, 'sharedAbstractions', absPath, `related ${absType} used by ${primary}`);
+        }
+      }
+    }
+
+    const inferredTests = inferRelatedTestsFromArtifacts({
+      candidateFiles: result.primaryTargets,
+      analogsMap: new Map(),
+      relationsMap,
+      limit: budget.maxFiles,
+    });
+
+    for (const inferredTest of inferredTests) {
+      addExplainedFile(result, 'relatedTests', inferredTest.filePath, inferredTest.reason);
+    }
+  }
+
+  if (shouldLoadAnalogArtifacts({
+    result,
+    taskType: classifiedType,
+    targetFile,
+    maxFiles: budget.maxFiles,
+    queryWasUsed,
+    preferLocalizedDirectContext,
+  })) {
+    const { analogsMap } = await loadRelatedTestArtifacts({
+      rootDir,
+      relationsArtifact,
+    });
+
+    // Step 3: Find analog files for primary targets
+    for (const primary of result.primaryTargets.slice(0, 2)) {
+      const analogs = analogsMap.get(primary) ?? [];
+      for (const analog of analogs.slice(0, 3)) {
+        if (result.primaryTargets.includes(analog.filePath)) {
+          continue;
+        }
+        addExplainedFile(
+          result,
+          'analogFiles',
+          analog.filePath,
+          `analog of ${primary}${analog.reason ? `; ${analog.reason}` : ''}`,
+        );
+      }
+    }
+
+    const inferredAnalogTests = inferRelatedTestsFromArtifacts({
+      candidateFiles: result.primaryTargets,
+      analogsMap,
+      relationsMap,
+      limit: budget.maxFiles,
+    });
+
+    for (const inferredTest of inferredAnalogTests) {
+      addExplainedFile(result, 'relatedTests', inferredTest.filePath, inferredTest.reason);
+    }
+  }
+
+  enforceContextBudget(result, budget.maxFiles);
+  includeDirectTestTargets(result);
+
+  return result;
+}
+
+export function classifyTask(intent) {
+  const lower = intent.toLowerCase();
+
+  // Check risky first (highest priority)
+  if (RISKY_SIGNALS.some((signal) => lower.includes(signal))) {
+    return 'non-trivial';
+  }
+
+  // Check trivial
+  if (TRIVIAL_SIGNALS.some((signal) => lower.includes(signal))) {
+    // But if intent also mentions multiple files or broad scope, upgrade
+    if (lower.includes('all ') || lower.includes('every ') || lower.includes('multiple')) {
+      return 'simple';
+    }
+    return 'trivial';
+  }
+
+  // Default to simple
+  return 'simple';
+}
+
+function shouldQueryIndex({
+  intent = '',
+  targetFile = null,
+  taskType = 'simple',
+} = {}) {
+  const normalizedIntent = String(intent || '').trim().toLowerCase();
+  if (!normalizedIntent) {
+    return false;
+  }
+
+  if (!targetFile) {
+    return true;
+  }
+
+  if (taskType === 'non-trivial') {
+    return true;
+  }
+
+  return EXPANSION_SIGNALS.some((signal) => normalizedIntent.includes(signal));
+}
+function enforceContextBudget(result, maxFiles) {
+  const prioritizedGroups = [
+    'primaryTargets',
+    'relatedTests',
+    'styleFiles',
+    'sharedAbstractions',
+    'analogFiles',
+  ];
+  const kept = new Set();
+
+  for (const group of prioritizedGroups) {
+    const nextItems = [];
+    for (const item of result[group] ?? []) {
+      if (kept.size >= maxFiles) {
+        break;
+      }
+      if (kept.has(item)) {
+        continue;
+      }
+      kept.add(item);
+      nextItems.push(item);
+    }
+    result[group] = nextItems;
+    result.explanations[group] = (result.explanations[group] ?? [])
+      .filter((entry) => nextItems.includes(entry.filePath));
+  }
+}
+
+function addExplainedFile(result, group, filePath, reason) {
+  if (!result[group].includes(filePath)) {
+    result[group].push(filePath);
+  }
+
+  const explanations = result.explanations[group] ?? [];
+  const existing = explanations.find((entry) => entry.filePath === filePath);
+  if (!existing) {
+    explanations.push({ filePath, reason });
+    result.explanations[group] = explanations;
+    return;
+  }
+
+  if (!existing.reason.includes(reason)) {
+    existing.reason = `${existing.reason}; ${reason}`;
+  }
+}
+
+function shouldLoadAnalogArtifacts({
+  result,
+  taskType = 'simple',
+  targetFile = null,
+  maxFiles = 5,
+  queryWasUsed = false,
+  preferLocalizedDirectContext = false,
+} = {}) {
+  const selectedCount = countSelectedFiles(result);
+  if (selectedCount >= maxFiles) {
+    return false;
+  }
+
+  if (preferLocalizedDirectContext) {
+    return false;
+  }
+
+  if (
+    taskType === 'trivial'
+    && targetFile
+    && !queryWasUsed
+    && (result.relatedTests?.length ?? 0) > 0
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
+function shouldPreferLocalizedDirectTargetContext({
+  result,
+  taskType = 'simple',
+  targetFile = null,
+  queryWasUsed = false,
+} = {}) {
+  if (queryWasUsed || !targetFile) {
+    return false;
+  }
+
+  if (taskType !== 'simple' && taskType !== 'trivial') {
+    return false;
+  }
+
+  return isTestLikeFile(targetFile)
+    || (result.relatedTests?.length ?? 0) > 0;
+}
+
+function countSelectedFiles(result) {
+  const selected = new Set();
+  for (const group of ['primaryTargets', 'relatedTests', 'styleFiles', 'sharedAbstractions', 'analogFiles']) {
+    for (const filePath of result[group] ?? []) {
+      selected.add(filePath);
+    }
+  }
+  return selected.size;
+}
+
+function buildQueryReason(queryResult) {
+  const reasons = queryResult.reasons ?? [];
+  if (reasons.length === 0) {
+    return 'query match';
+  }
+  return `query match: ${reasons.join(', ')}`;
+}
+
+function includeDirectTestTargets(result) {
+  for (const primaryTarget of result.primaryTargets ?? []) {
+    if (!isTestLikeFile(primaryTarget)) {
+      continue;
+    }
+    addExplainedFile(result, 'relatedTests', primaryTarget, `direct test target ${primaryTarget}`);
+  }
+}
+
+function isTestLikeFile(filePath) {
+  return /\.(test|spec)\.[a-z0-9]+$/i.test(filePath)
+    || /(^|\/)(?:__tests__|tests?|specs?)\//i.test(filePath);
+}