@archora/core 1.1.0 → 2.0.0

package/src/search/index.ts

@@ -1,18 +1,18 @@
-// Глобальный поиск по `ScanResult` — без чтения файловой системы, только
-// по структурированным метаданным (modules + edges). Стратегия:
+// Global search over `ScanResult` — no filesystem reads, only structured
+// metadata (modules + edges). Strategy:
 //
-// 1. Парсим query (`parseQuery`).
-// 2. Для каждого префикса набираем set'ы ID-кандидатов; в финальный набор
-//    попадают только модули, прошедшие пересечение всех префиксов (AND).
-// 3. Поверх отфильтрованных модулей применяем free-text ранкинг
-//    (substring-match по path и exports) и сортируем по итоговому скору.
-// 4. Возвращаем разноимённые результаты с типом матча — UI рендерит pill-чипы
-//    «Path / Export / Import / Kind», поэтому каждому SearchResult нужно знать,
-//    почему он попал в выдачу.
+// 1. Parse the query (`parseQuery`).
+// 2. For each prefix collect sets of candidate IDs; only modules that pass
+//    the intersection of all prefixes (AND) make it into the final set.
+// 3. On top of the filtered modules apply free-text ranking (substring match
+//    over path and exports) and sort by the resulting score.
+// 4. Return results tagged with the match kind — the UI renders pill chips
+//    "Path / Export / Import / Kind", so each SearchResult must know why it
+//    ended up in the output.
 //
-// Не делаем: ripgrep по содержимому файлов, fuzzy-substring (типа
-// fzf-style scoring) — для path → modules.length обычно сотни, обычный
-// substring достаточен. Усложним, если появится сигнал «слишком шумно».
+// We do not: ripgrep over file contents, fuzzy substring (fzf-style scoring) —
+// for path → modules.length is usually in the hundreds, plain substring is
+// enough. We'll add complexity if a "too noisy" signal shows up.
 
 import type { ScanResult, ModuleId, ModuleKind } from '../analyzer/types';
 import { parseQuery, isEmpty, type ParsedQuery, type SearchPrefix } from './parseQuery';
@@ -24,20 +24,20 @@ export type MatchKind = 'path' | 'export' | 'import' | 'kind';
 export interface SearchResult {
   /** Module id (relative path). */
   id: ModuleId;
-  /** Какие критерии сработали — UI использует для подсветки чипов. */
+  /** Which criteria matched — the UI uses this to highlight chips. */
   matched: MatchKind[];
-  /** Score 0..1; 1 = идеальное соответствие, 0 = только prefix-фильтр прошёл. */
+  /** Score 0..1; 1 = perfect match, 0 = only the prefix filter passed. */
   score: number;
   /**
-   * Подсветочный hint для каждого совпавшего критерия — конкретные значения
-   * (имя экспорта, specifier импорта, kind). Используется панелью результатов
-   * для пояснения «почему этот модуль вылез на этот запрос».
+   * Highlight hint for each matched criterion — the concrete values
+   * (export name, import specifier, kind). Used by the results panel to
+   * explain "why this module surfaced for this query".
    */
   highlights: Partial<Record<MatchKind, string[]>>;
 }
 
 export interface SearchOptions {
-  /** Ограничить размер выдачи. По умолчанию 50 — типовой UI-overlay. */
+  /** Cap the output size. Defaults to 50 — a typical UI overlay. */
   limit?: number;
 }
 
@@ -54,17 +54,17 @@ export function search(
   const limit = options.limit ?? DEFAULT_LIMIT;
   const moduleIds = new Set(scan.modules.map((m) => m.id));
 
-  // 1. Префиксные фильтры выдают `Map<id, MatchKind[]> + highlights` —
-  // если префикс есть, попасть в выдачу можно только пройдя его.
+  // 1. Prefix filters yield `Map<id, MatchKind[]> + highlights` — if a prefix
+  // is present, a module can only reach the output by passing it.
   const prefixHits = collectPrefixHits(scan, parsed);
 
-  // Если есть префиксы — оставляем только модули, попавшие во все указанные.
+  // If there are prefixes — keep only modules that hit all of the given ones.
   const eligibleIds = applyPrefixIntersection(moduleIds, prefixHits, parsed.prefixes);
 
-  // 2. Free-text ранкинг. Если free пуст и префиксы есть — отдаём eligible
-  // как есть со скором 0.5 (нейтральный). Если free есть — считаем скор и
-  // отбрасываем модули, у которых ни один free-токен не сматчился, КОГДА
-  // префиксов нет; иначе free снижает скор, но не отсекает.
+  // 2. Free-text ranking. If free is empty and prefixes exist — return eligible
+  // as is with score 0.5 (neutral). If free is present — compute the score and
+  // drop modules where no free token matched WHEN there are no prefixes;
+  // otherwise free lowers the score but does not cut a module out.
   const results: SearchResult[] = [];
   for (const id of eligibleIds) {
     const module = scan.modules.find((m) => m.id === id);
@@ -72,7 +72,7 @@ export function search(
     const matched: MatchKind[] = [];
     const highlights: Partial<Record<MatchKind, string[]>> = {};
 
-    // соберём подтверждения от префикс-хитов
+    // collect confirmations from prefix hits
     for (const kind of ['path', 'export', 'import', 'kind'] as const) {
       const hit = prefixHits[kind].get(id);
       if (hit) {
@@ -95,7 +95,7 @@ export function search(
           (highlights.export ??= []).push(...f.matchedExports);
         }
       } else if (matched.length === 0) {
-        // Нет ни префикс-матча, ни free-матча: модуль вообще не попал.
+        // Neither a prefix match nor a free match: the module is out entirely.
         continue;
       }
     }
@@ -104,8 +104,8 @@ export function search(
     results.push({ id, matched, score, highlights });
   }
 
-  // 3. Сортировка: больший score → раньше; tiebreak по короче-путь → раньше
-  // (короткие пути обычно ближе к корню фичи, чем глубокие имплементации).
+  // 3. Sort: higher score → first; tiebreak by shorter path → first
+  // (short paths usually sit closer to a feature root than deep implementations).
   results.sort((a, b) => {
     if (b.score !== a.score) return b.score - a.score;
     return a.id.length - b.id.length;
@@ -157,7 +157,7 @@ function collectPrefixHits(scan: ScanResult, q: ParsedQuery): PrefixHits {
   }
 
   if (q.prefixes.import) {
-    // edges.specifier — оригинальная строка импорта; non-resolved тоже учитываем
+    // edges.specifier — the original import string; non-resolved are counted too
     const needles = q.prefixes.import;
     const matchedSpecifiersByModule = new Map<ModuleId, Set<string>>();
     for (const e of scan.edges) {
@@ -213,16 +213,16 @@ interface FreeTextMatch {
 }
 
 /**
- * Простой substring-ранкер. Не fuzzy: для типичной задачи «найди useAuth»
- * подстрока даёт стабильные результаты без шумовых матчей.
+ * Plain substring ranker. Not fuzzy: for the typical "find useAuth" task a
+ * substring gives stable results without noisy matches.
  *
- * Скоринг:
- * - Точное совпадение exports[i] === term: +0.5
+ * Scoring:
+ * - Exact match exports[i] === term: +0.5
  * - exports[i] contains term: +0.25
  * - basename(path) === term: +0.4
- * - path contains term: +0.2 (но в score раз — чтобы три совпадения не
- *   делали скор > 1)
- * Затем нормализуем в 0..1 по числу term'ов.
+ * - path contains term: +0.2 (but counted once in the score — so that three
+ *   matches don't push the score > 1)
+ * Then normalize to 0..1 by the number of terms.
  */
 function scoreFreeText(id: ModuleId, exports: readonly string[], terms: string[]): FreeTextMatch {
   let score = 0;
@@ -260,7 +260,7 @@ function scoreFreeText(id: ModuleId, exports: readonly string[], terms: string[]
     score += bestForTerm;
   }
 
-  // Нормализуем: максимум 0.5 за term — top score 1.0 при N term'ов.
+  // Normalize: max 0.5 per term — top score 1.0 with N terms.
   const normalized = terms.length > 0 ? Math.min(1, score / (terms.length * 0.5)) : 0;
   return {
     score: normalized,

package/src/search/parseQuery.ts

@@ -1,23 +1,23 @@
-// Парсер query-строки для глобального поиска. Поддерживает префиксы
-// `path:`, `export:`, `import:`, `kind:`, разделяемые пробелами; всё, что
-// без префикса — free-text токены, которые ранкер использует одновременно
-// по path и exports.
+// Parser for the global-search query string. Supports the prefixes `path:`,
+// `export:`, `import:`, `kind:`, separated by spaces; anything without a
+// prefix is a free-text token that the ranker uses against both path and
+// exports at once.
 //
-// Несколько префиксов в одной строке = AND-пересечение
-// (`kind:component path:auth` → component-модули, у которых path содержит auth).
-// Несколько одинаковых префиксов = OR внутри ключа
-// (`kind:component kind:composable` → component ИЛИ composable).
+// Several prefixes in one string = AND intersection
+// (`kind:component path:auth` → component modules whose path contains auth).
+// Several identical prefixes = OR within a key
+// (`kind:component kind:composable` → component OR composable).
 //
-// Значения префиксов могут содержать кавычки, чтобы пробелы не дробили токен:
-// `path:"src/feature x"`. Кавычки внутри значения не поддерживаются — это
-// query-строка, а не shell-парсер.
+// Prefix values may use quotes so spaces don't split the token:
+// `path:"src/feature x"`. Quotes inside a value are not supported — this is a
+// query string, not a shell parser.
 
 export type SearchPrefix = 'path' | 'export' | 'import' | 'kind';
 
 export interface ParsedQuery {
-  /** Свободные токены без префикса. Пустой массив, если все — префиксированы. */
+  /** Free tokens without a prefix. Empty array if all are prefixed. */
   free: string[];
-  /** Значения, сгруппированные по ключу. Пустой объект → нет префиксов. */
+  /** Values grouped by key. Empty object → no prefixes. */
   prefixes: Partial<Record<SearchPrefix, string[]>>;
 }
 

package/src/views/__tests__/analyzerViews.test.ts

@@ -168,12 +168,18 @@ describe('analyzer view helpers', () => {
         changedModules: [],
         newCycles: current.cycles,
         resolvedCycles: [],
+        newLayerViolations: [],
+        resolvedLayerViolations: [],
+        newContractViolations: [],
+        resolvedContractViolations: [],
         summary: {
           addedModules: 0,
           removedModules: 0,
           changedModules: 0,
           newCycles: current.cycles.length,
           resolvedCycles: 0,
+          newLayerViolations: 0,
+          newContractViolations: 0,
         },
       },
     });

package/src/views/analyzerViews.ts

@@ -10,6 +10,7 @@ import type {
 import { detectLayer } from '../analyzer/layers';
 import { diffScans } from '../diff';
 import type { ScanDiff } from '../diff/types';
+import { isReviewModule } from '../report/buildDeadCodeReport';
 
 export type MatrixGrouping = 'area' | 'layer' | 'folder' | 'package';
 
@@ -1188,12 +1189,6 @@ function isSourceFile(part: string): boolean {
   return /\.[cm]?[jt]sx?$/u.test(part) || /\.(vue|svelte)$/u.test(part);
 }
 
-function isReviewModule(id: ModuleId): boolean {
-  return !/(^|\/)(fixtures|test\/fixtures|__fixtures__|__tests__|__mocks__)(\/|$)|\.(test|spec)\./u.test(
-    id,
-  );
-}
-
 function stripExtension(part: string): string {
   return part.replace(/\.[^.]+$/u, '');
 }