@rigour-labs/core 6.7.10 → 6.8.1-rc.1

package/dist/pattern-index/indexer.test.js

@@ -1,197 +0,0 @@
-/**
- * Pattern Indexer Tests
- *
- * Comprehensive tests for the pattern indexer.
- */
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-import { PatternIndexer, savePatternIndex, loadPatternIndex } from './indexer.js';
-describe('PatternIndexer', () => {
-    let testDir;
-    beforeEach(async () => {
-        // Create a temporary test directory
-        testDir = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-test-'));
-        await fs.mkdir(path.join(testDir, 'src'), { recursive: true });
-    });
-    afterEach(async () => {
-        // Clean up
-        await fs.rm(testDir, { recursive: true, force: true });
-    });
-    describe('buildIndex', () => {
-        it('should index function declarations', async () => {
-            await fs.writeFile(path.join(testDir, 'src', 'utils.ts'), `
-/**
- * Format a date to a readable string.
- */
-export function formatDate(date: Date): string {
-    return date.toISOString();
-}
-                `);
-            const indexer = new PatternIndexer(testDir);
-            const index = await indexer.buildIndex();
-            expect(index.patterns).toHaveLength(1);
-            expect(index.patterns[0].name).toBe('formatDate');
-            expect(index.patterns[0].type).toBe('function');
-            expect(index.patterns[0].exported).toBe(true);
-            expect(index.patterns[0].signature).toContain('date: Date');
-            expect(index.patterns[0].description).toContain('Format a date');
-        });
-        it('should index source files nested in monorepo packages', async () => {
-            const packageSrc = path.join(testDir, 'packages', 'api', 'src');
-            await fs.mkdir(packageSrc, { recursive: true });
-            await fs.writeFile(path.join(packageSrc, 'handler.ts'), 'export function handleRequest() {}');
-            const indexer = new PatternIndexer(testDir);
-            const index = await indexer.buildIndex();
-            expect(index.files.map(file => file.path)).toContain(path.join('packages', 'api', 'src', 'handler.ts'));
-            expect(index.patterns.some(pattern => pattern.name === 'handleRequest')).toBe(true);
-        });
-        it('should index arrow functions', async () => {
-            await fs.writeFile(path.join(testDir, 'src', 'helpers.ts'), `
-export const slugify = (text: string): string => {
-    return text.toLowerCase().replace(/\\s+/g, '-');
-};
-                `);
-            const indexer = new PatternIndexer(testDir);
-            const index = await indexer.buildIndex();
-            expect(index.patterns).toHaveLength(1);
-            expect(index.patterns[0].name).toBe('slugify');
-            expect(index.patterns[0].type).toBe('function');
-        });
-        it('should detect React hooks', async () => {
-            await fs.writeFile(path.join(testDir, 'src', 'hooks.ts'), `
-export const useAuth = () => {
-    return { user: null, login: () => {} };
-};
-                `);
-            const indexer = new PatternIndexer(testDir);
-            const index = await indexer.buildIndex();
-            expect(index.patterns).toHaveLength(1);
-            expect(index.patterns[0].name).toBe('useAuth');
-            expect(index.patterns[0].type).toBe('hook');
-        });
-        it('should index classes', async () => {
-            await fs.writeFile(path.join(testDir, 'src', 'services.ts'), `
-export class UserService {
-    getUser(id: string) {
-        return { id };
-    }
-}
-                `);
-            const indexer = new PatternIndexer(testDir);
-            const index = await indexer.buildIndex();
-            expect(index.patterns.some(p => p.name === 'UserService')).toBe(true);
-            expect(index.patterns.find(p => p.name === 'UserService')?.type).toBe('class');
-        });
-        it('should detect error classes', async () => {
-            await fs.writeFile(path.join(testDir, 'src', 'errors.ts'), `
-export class ValidationError extends Error {
-    constructor(message: string) {
-        super(message);
-    }
-}
-                `);
-            const indexer = new PatternIndexer(testDir);
-            const index = await indexer.buildIndex();
-            expect(index.patterns[0].type).toBe('error');
-        });
-        it('should index interfaces', async () => {
-            await fs.writeFile(path.join(testDir, 'src', 'types.ts'), `
-export interface User {
-    id: string;
-    name: string;
-    email: string;
-}
-                `);
-            const indexer = new PatternIndexer(testDir);
-            const index = await indexer.buildIndex();
-            expect(index.patterns).toHaveLength(1);
-            expect(index.patterns[0].name).toBe('User');
-            expect(index.patterns[0].type).toBe('interface');
-        });
-        it('should index type aliases', async () => {
-            await fs.writeFile(path.join(testDir, 'src', 'types.ts'), `
-export type UserId = string;
-                `);
-            const indexer = new PatternIndexer(testDir);
-            const index = await indexer.buildIndex();
-            expect(index.patterns).toHaveLength(1);
-            expect(index.patterns[0].type).toBe('type');
-        });
-        it('should index enums', async () => {
-            await fs.writeFile(path.join(testDir, 'src', 'constants.ts'), `
-export enum Status {
-    Active = 'active',
-    Inactive = 'inactive'
-}
-                `);
-            const indexer = new PatternIndexer(testDir);
-            const index = await indexer.buildIndex();
-            expect(index.patterns).toHaveLength(1);
-            expect(index.patterns[0].name).toBe('Status');
-            expect(index.patterns[0].type).toBe('enum');
-        });
-        it('should index constants (all caps)', async () => {
-            await fs.writeFile(path.join(testDir, 'src', 'config.ts'), `
-export const API_URL = 'https://api.example.com';
-export const MAX_RETRIES = 3;
-                `);
-            const indexer = new PatternIndexer(testDir);
-            const index = await indexer.buildIndex();
-            const constants = index.patterns.filter(p => p.type === 'constant');
-            expect(constants.length).toBeGreaterThanOrEqual(1);
-            expect(constants.some(c => c.name === 'API_URL')).toBe(true);
-        });
-        it('should track index statistics', async () => {
-            await fs.writeFile(path.join(testDir, 'src', 'utils.ts'), `
-export function foo() {}
-export function bar() {}
-export interface Baz {}
-                `);
-            const indexer = new PatternIndexer(testDir);
-            const index = await indexer.buildIndex();
-            expect(index.stats.totalPatterns).toBe(3);
-            expect(index.stats.totalFiles).toBe(1);
-            expect(index.stats.indexDurationMs).toBeGreaterThan(0);
-        });
-        it('should exclude test files by default', async () => {
-            await fs.writeFile(path.join(testDir, 'src', 'utils.ts'), 'export function main() {}');
-            await fs.writeFile(path.join(testDir, 'src', 'utils.test.ts'), 'export function testMain() {}');
-            const indexer = new PatternIndexer(testDir);
-            const index = await indexer.buildIndex();
-            expect(index.patterns.every(p => !p.file.includes('.test.'))).toBe(true);
-        });
-    });
-    describe('updateIndex (incremental)', () => {
-        it('should only reindex changed files', async () => {
-            // Initial index
-            await fs.writeFile(path.join(testDir, 'src', 'a.ts'), 'export function funcA() {}');
-            await fs.writeFile(path.join(testDir, 'src', 'b.ts'), 'export function funcB() {}');
-            const indexer = new PatternIndexer(testDir);
-            const initialIndex = await indexer.buildIndex();
-            expect(initialIndex.patterns).toHaveLength(2);
-            // Modify only one file
-            await fs.writeFile(path.join(testDir, 'src', 'a.ts'), 'export function funcA() {} export function funcA2() {}');
-            const updatedIndex = await indexer.updateIndex(initialIndex);
-            expect(updatedIndex.patterns).toHaveLength(3);
-        });
-    });
-    describe('savePatternIndex / loadPatternIndex', () => {
-        it('should save and load index correctly', async () => {
-            await fs.writeFile(path.join(testDir, 'src', 'utils.ts'), 'export function myFunc() {}');
-            const indexer = new PatternIndexer(testDir);
-            const index = await indexer.buildIndex();
-            const indexPath = path.join(testDir, '.rigour', 'patterns.json');
-            await savePatternIndex(index, indexPath);
-            const loaded = await loadPatternIndex(indexPath);
-            expect(loaded).not.toBeNull();
-            expect(loaded.patterns).toHaveLength(index.patterns.length);
-            expect(loaded.version).toBe(index.version);
-        });
-        it('should return null for non-existent index', async () => {
-            const loaded = await loadPatternIndex('/non/existent/path.json');
-            expect(loaded).toBeNull();
-        });
-    });
-});

package/dist/pattern-index/matcher.test.d.ts

@@ -1,6 +0,0 @@
-/**
- * Pattern Matcher Tests
- *
- * Comprehensive tests for the pattern matcher.
- */
-export {};

package/dist/pattern-index/matcher.test.js

@@ -1,238 +0,0 @@
-/**
- * Pattern Matcher Tests
- *
- * Comprehensive tests for the pattern matcher.
- */
-import { describe, it, expect } from 'vitest';
-import { PatternMatcher, checkPatternDuplicate } from './matcher.js';
-// Helper to create a mock pattern
-function createPattern(overrides = {}) {
-    return {
-        id: 'test-id',
-        type: 'function',
-        name: 'testFunction',
-        file: 'src/utils.ts',
-        line: 1,
-        endLine: 5,
-        signature: '(input: string): string',
-        description: 'A test function',
-        keywords: ['test', 'function'],
-        hash: 'abc123',
-        exported: true,
-        usageCount: 0,
-        indexedAt: new Date().toISOString(),
-        ...overrides
-    };
-}
-// Helper to create a mock index
-function createIndex(patterns) {
-    return {
-        version: '1.0.0',
-        lastUpdated: new Date().toISOString(),
-        rootDir: '/test',
-        patterns,
-        stats: {
-            totalPatterns: patterns.length,
-            totalFiles: 1,
-            byType: { function: patterns.length },
-            indexDurationMs: 100
-        },
-        files: []
-    };
-}
-describe('PatternMatcher', () => {
-    describe('exact name match', () => {
-        it('should find exact name matches with 100% confidence', async () => {
-            const pattern = createPattern({ name: 'formatDate' });
-            const index = createIndex([pattern]);
-            const matcher = new PatternMatcher(index, { useEmbeddings: false });
-            const result = await matcher.match({ name: 'formatDate' });
-            expect(result.status).toBe('FOUND_SIMILAR');
-            expect(result.matches).toHaveLength(1);
-            expect(result.matches[0].matchType).toBe('exact');
-            expect(result.matches[0].confidence).toBe(100);
-        });
-        it('should be case-insensitive for exact matches', async () => {
-            const pattern = createPattern({ name: 'formatDate' });
-            const index = createIndex([pattern]);
-            const matcher = new PatternMatcher(index, { useEmbeddings: false });
-            const result = await matcher.match({ name: 'FormatDate' });
-            expect(result.matches).toHaveLength(1);
-            expect(result.matches[0].matchType).toBe('exact');
-        });
-        it('should set action to BLOCK for exact matches', async () => {
-            const pattern = createPattern({ name: 'formatDate' });
-            const index = createIndex([pattern]);
-            const matcher = new PatternMatcher(index, { useEmbeddings: false });
-            const result = await matcher.match({ name: 'formatDate' });
-            expect(result.action).toBe('BLOCK');
-        });
-    });
-    describe('fuzzy name match', () => {
-        it('should find fuzzy matches for similar names', async () => {
-            const pattern = createPattern({ name: 'formatDate' });
-            const index = createIndex([pattern]);
-            const matcher = new PatternMatcher(index, { useEmbeddings: false });
-            // 'formatDate' vs 'formatDates' have extremely high similarity
-            const result = await matcher.match({ name: 'formatDates' });
-            expect(result.status).toBe('FOUND_SIMILAR');
-            expect(result.matches.some(m => m.matchType === 'fuzzy')).toBe(true);
-        });
-        it('should find matches for renamed patterns', async () => {
-            const pattern = createPattern({
-                name: 'formatDate',
-                keywords: ['format', 'date']
-            });
-            const index = createIndex([pattern]);
-            const matcher = new PatternMatcher(index, { useEmbeddings: false });
-            const result = await matcher.match({ name: 'formatDateString' });
-            expect(result.matches.length).toBeGreaterThan(0);
-        });
-        it('should not match completely unrelated names', async () => {
-            const pattern = createPattern({ name: 'formatDate' });
-            const index = createIndex([pattern]);
-            const matcher = new PatternMatcher(index, { useEmbeddings: false });
-            const result = await matcher.match({ name: 'sendEmail' });
-            expect(result.status).toBe('NO_MATCH');
-        });
-    });
-    describe('signature match', () => {
-        it('should find matches with identical signatures', async () => {
-            const pattern = createPattern({
-                name: 'formatDate',
-                signature: '(date: Date): string'
-            });
-            const index = createIndex([pattern]);
-            const matcher = new PatternMatcher(index, { useEmbeddings: false });
-            const result = await matcher.match({
-                name: 'myDateFormatter',
-                signature: '(date: Date): string'
-            });
-            expect(result.matches.some(m => m.matchType === 'signature')).toBe(true);
-        });
-        it('should match similar parameter patterns', async () => {
-            const pattern = createPattern({
-                name: 'formatDate',
-                signature: '(date: Date, format: string): string'
-            });
-            const index = createIndex([pattern]);
-            const matcher = new PatternMatcher(index, { useEmbeddings: false });
-            const result = await matcher.match({
-                signature: '(input: Date, pattern: string): string'
-            });
-            expect(result.matches.length).toBeGreaterThan(0);
-        });
-    });
-    describe('keyword match', () => {
-        it('should find matches based on keywords', async () => {
-            const pattern = createPattern({
-                name: 'formatDate',
-                keywords: ['format', 'date', 'time']
-            });
-            const index = createIndex([pattern]);
-            const matcher = new PatternMatcher(index, { useEmbeddings: false });
-            const result = await matcher.match({
-                keywords: ['date', 'format']
-            });
-            expect(result.matches.some(m => m.matchType === 'semantic')).toBe(true);
-        });
-    });
-    describe('overrides', () => {
-        it('should allow overridden patterns', async () => {
-            const pattern = createPattern({ name: 'formatDate' });
-            const index = createIndex([pattern]);
-            const matcher = new PatternMatcher(index, { useEmbeddings: false }, [
-                {
-                    pattern: 'formatDate',
-                    reason: 'Refactoring in progress',
-                    createdAt: new Date().toISOString()
-                }
-            ]);
-            const result = await matcher.match({ name: 'formatDate' });
-            expect(result.status).toBe('OVERRIDE_ALLOWED');
-            expect(result.action).toBe('ALLOW');
-        });
-        it('should support glob overrides', async () => {
-            const pattern = createPattern({ name: 'formatDate' });
-            const index = createIndex([pattern]);
-            const matcher = new PatternMatcher(index, { useEmbeddings: false }, [
-                {
-                    pattern: 'format*',
-                    reason: 'All format functions are exempt',
-                    createdAt: new Date().toISOString()
-                }
-            ]);
-            const result = await matcher.match({ name: 'formatDate' });
-            expect(result.status).toBe('OVERRIDE_ALLOWED');
-        });
-        it('should ignore expired overrides', async () => {
-            const pattern = createPattern({ name: 'formatDate' });
-            const index = createIndex([pattern]);
-            const matcher = new PatternMatcher(index, { useEmbeddings: false }, [
-                {
-                    pattern: 'formatDate',
-                    reason: 'Expired override',
-                    createdAt: '2020-01-01T00:00:00Z',
-                    expiresAt: '2020-01-02T00:00:00Z' // Expired
-                }
-            ]);
-            const result = await matcher.match({ name: 'formatDate' });
-            expect(result.status).toBe('FOUND_SIMILAR');
-        });
-    });
-    describe('configuration', () => {
-        it('should respect minConfidence setting', async () => {
-            const pattern = createPattern({ name: 'formatDate' });
-            const index = createIndex([pattern]);
-            const matcher = new PatternMatcher(index, { minConfidence: 95, useEmbeddings: false });
-            // Fuzzy match won't meet 95% threshold
-            const result = await matcher.match({ name: 'dateFormat' });
-            // Should only include exact matches at 95%+ threshold
-            expect(result.matches.every(m => m.confidence >= 95)).toBe(true);
-        });
-        it('should respect maxMatches setting', async () => {
-            const patterns = [
-                createPattern({ id: '1', name: 'formatDate1' }),
-                createPattern({ id: '2', name: 'formatDate2' }),
-                createPattern({ id: '3', name: 'formatDate3' }),
-                createPattern({ id: '4', name: 'formatDate4' }),
-            ];
-            const index = createIndex(patterns);
-            const matcher = new PatternMatcher(index, { maxMatches: 2, useEmbeddings: false });
-            const result = await matcher.match({ name: 'formatDate' });
-            expect(result.matches.length).toBeLessThanOrEqual(2);
-        });
-    });
-    describe('suggestions', () => {
-        it('should suggest importing exported patterns', async () => {
-            const pattern = createPattern({
-                name: 'formatDate',
-                file: 'src/utils/date.ts',
-                exported: true
-            });
-            const index = createIndex([pattern]);
-            const matcher = new PatternMatcher(index, { useEmbeddings: false });
-            const result = await matcher.match({ name: 'formatDate' });
-            expect(result.suggestion).toContain('Import');
-            expect(result.suggestion).toContain('src/utils/date.ts');
-        });
-        it('should suggest extracting non-exported patterns', async () => {
-            const pattern = createPattern({
-                name: 'formatDate',
-                exported: false
-            });
-            const index = createIndex([pattern]);
-            const matcher = new PatternMatcher(index, { useEmbeddings: false });
-            const result = await matcher.match({ name: 'formatDate' });
-            expect(result.suggestion).toContain('similar pattern');
-        });
-    });
-});
-describe('checkPatternDuplicate', () => {
-    it('should be a quick helper for duplicate checking', async () => {
-        const pattern = createPattern({ name: 'myUtil' });
-        const index = createIndex([pattern]);
-        const result = await checkPatternDuplicate(index, 'myUtil');
-        expect(result.status).toBe('FOUND_SIMILAR');
-    });
-});

package/dist/pattern-index/pattern-reuse.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/pattern-index/pattern-reuse.test.js

@@ -1,76 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-/** Topic vectors: one dimension per word, so similarity between texts is predictable. */
-const TOPICS = ['retry', 'backoff', 'request', 'date', 'format', 'chart'];
-const topicVector = (text) => TOPICS.map(t => (text.toLowerCase().includes(t) ? 1 : 0));
-vi.mock('./embeddings.js', async (importOriginal) => {
-    const real = await importOriginal();
-    return {
-        ...real,
-        generateEmbedding: async (text) => topicVector(text),
-        embedPattern: async (p) => topicVector(real.patternEmbeddingText(p)),
-    };
-});
-const { patternEmbeddingText, EMBEDDING_TEXT_VERSION } = await import('./embeddings.js');
-const { PatternMatcher, SEMANTIC_MATCH_FLOOR } = await import('./matcher.js');
-const { PatternIndexer } = await import('./indexer.js');
-const { assessPattern } = await import('./assess.js');
-const pattern = (name, extra = {}) => ({
-    id: name, type: 'function', name, file: 'src/util.ts', line: 1, endLine: 3, signature: '', description: '',
-    keywords: [], hash: name, exported: true, usageCount: 0, indexedAt: '2026-10-02T00:00:00Z', ...extra,
-});
-const index = (patterns, version) => ({
-    version: '1.0.0', lastUpdated: '', rootDir: '/x', patterns, files: [],
-    stats: { totalPatterns: patterns.length, totalFiles: 1, byType: {}, indexDurationMs: 0 },
-    ...(version ? { embeddingTextVersion: version } : {}),
-});
-describe('pattern embedding text', () => {
-    it('reads a name as words, which is what lets an intent find it', () => {
-        expect(patternEmbeddingText({ name: 'retryWithBackoff', type: 'function' })).toBe('retry with backoff function');
-        expect(patternEmbeddingText({ name: 'parse_csv-rows', type: 'function', description: 'Rows from a file' })).toBe('parse csv rows function Rows from a file');
-    });
-});
-describe('matching by meaning', () => {
-    it(`accepts a match by meaning at ${SEMANTIC_MATCH_FLOOR}, below the bar name matching keeps`, async () => {
-        // The query shares 1 of 3 topics with the pattern: cosine 0.58, under the old 0.60.
-        const retry = pattern('retryWithBackoff', { embedding: topicVector('retry backoff request') });
-        const result = await new PatternMatcher(index([retry]), { useFuzzy: false }).match({ name: 'callAgain', intent: 'make the request work on a flaky network' });
-        expect(result.matches.map(m => [m.pattern.name, m.matchType])).toEqual([['retryWithBackoff', 'semantic']]);
-        expect(result.action).toBe('WARN');
-    });
-    it('returns nothing for an unrelated intent', async () => {
-        const retry = pattern('retryWithBackoff', { embedding: topicVector('retry backoff request') });
-        const result = await new PatternMatcher(index([retry]), { useFuzzy: false }).match({ name: 'drawPie', intent: 'render a pie chart' });
-        expect(result.status).toBe('NO_MATCH');
-    });
-});
-describe('enrichIndex', () => {
-    it('re-embeds an index built from an older embedding text, and marks the version', async () => {
-        const stale = index([pattern('formatDate', { embedding: [9, 9, 9, 9, 9, 9] })], 1);
-        const enriched = await new PatternIndexer('/x', { useEmbeddings: true }).enrichIndex(stale);
-        expect(enriched.embeddingTextVersion).toBe(EMBEDDING_TEXT_VERSION);
-        expect(enriched.patterns[0].embedding).toEqual(topicVector('format date function'));
-    });
-});
-describe('assessPattern', () => {
-    let cwd;
-    beforeEach(() => {
-        cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'assess-'));
-        fs.mkdirSync(path.join(cwd, 'src'));
-        fs.writeFileSync(path.join(cwd, 'package.json'), JSON.stringify({ dependencies: { 'react-dom': '18.2.0' } }));
-        fs.writeFileSync(path.join(cwd, 'src/mount.ts'), 'export function mountApp(el) {\n  ReactDOM.render(<App />, el);\n}\n');
-    });
-    afterEach(() => fs.rmSync(cwd, { recursive: true, force: true }));
-    it('blocks an exact duplicate and reports what is deprecated inside the function it would reuse', async () => {
-        const mount = pattern('mountApp', { file: 'src/mount.ts', line: 1, endLine: 3 });
-        const result = await assessPattern(cwd, index([mount]), { name: 'mountApp' });
-        expect(result.action).toBe('BLOCK');
-        expect(result.deprecations.map(d => d.replacement)).toEqual(['createRoot(container).render(<App />)']);
-    });
-    it('allows a name nothing resembles', async () => {
-        const result = await assessPattern(cwd, index([pattern('mountApp', { file: 'src/mount.ts' })]), { name: 'exportPdfReport' });
-        expect(result).toEqual({ action: 'ALLOW', suggestion: '', deprecations: [] });
-    });
-});

package/dist/pattern-index/semantic-runtime.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/pattern-index/semantic-runtime.test.js

@@ -1,31 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { locateTransformers, semanticRuntimeDir, semanticRuntimeInstalled } from './semantic-runtime.js';
-let home;
-const original = process.env.RIGOUR_HOME;
-beforeEach(() => {
-    home = fs.mkdtempSync(path.join(os.tmpdir(), 'semantic-home-'));
-    process.env.RIGOUR_HOME = home;
-});
-afterEach(() => {
-    process.env.RIGOUR_HOME = original;
-    fs.rmSync(home, { recursive: true, force: true });
-});
-describe('the semantic runtime', () => {
-    it('lives in Rigour\'s home, shared by every Rigour version, and is seen there once installed', () => {
-        expect(semanticRuntimeDir()).toBe(path.join(home, '.rigour', 'runtime', 'semantic'));
-        expect(semanticRuntimeInstalled()).toBe(false);
-        const pkg = path.join(semanticRuntimeDir(), 'node_modules', '@xenova', 'transformers');
-        fs.mkdirSync(pkg, { recursive: true });
-        fs.writeFileSync(path.join(pkg, 'package.json'), JSON.stringify({ name: '@xenova/transformers', main: 'index.js' }));
-        fs.writeFileSync(path.join(pkg, 'index.js'), 'module.exports = {};');
-        expect(semanticRuntimeInstalled()).toBe(true);
-        expect(locateTransformers(home)).toBeDefined();
-    });
-    it('is not a dependency of the published package: the 240 MB is installed once, never per version', () => {
-        const manifest = JSON.parse(fs.readFileSync(path.join(__dirname, '../../package.json'), 'utf8'));
-        expect({ ...manifest.dependencies, ...manifest.optionalDependencies }).not.toHaveProperty('@xenova/transformers');
-    });
-});

package/dist/pattern-index/staleness.test.d.ts

@@ -1,6 +0,0 @@
-/**
- * Staleness Detector Tests
- *
- * Tests for the staleness detection system.
- */
-export {};