@rigour-labs/core 6.8.0 → 6.8.1

package/dist/inference/http-download.test.js

@@ -1,109 +0,0 @@
-import fs from 'fs-extra';
-import os from 'os';
-import path from 'path';
-import { createHash } from 'crypto';
-import { Readable, PassThrough } from 'stream';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { downloadToFile } from './http-download.js';
-const PAYLOAD = Buffer.from('0123456789abcdefghijklmnopqrstuvwxyz');
-const sha = (b) => createHash('sha256').update(b).digest('hex');
-function response(statusCode, body = Buffer.alloc(0), headers = {}) {
-    return { statusCode, headers, body: Buffer.isBuffer(body) ? Readable.from([body]) : body };
-}
-/** Serves PAYLOAD, honouring Range unless told not to. */
-function server(opts = {}) {
-    const calls = [];
-    const get = async (url, headers) => {
-        calls.push({ url, headers });
-        const range = headers.Range?.match(/bytes=(\d+)-/);
-        if (range && opts.honourRange !== false) {
-            const start = Number(range[1]);
-            if (start >= PAYLOAD.length)
-                return response(416);
-            return response(206, PAYLOAD.subarray(start), { 'content-length': String(PAYLOAD.length - start) });
-        }
-        return response(200, PAYLOAD, { 'content-length': String(PAYLOAD.length), etag: opts.etag });
-    };
-    return { get, calls };
-}
-describe('downloadToFile', () => {
-    let dir;
-    let dest;
-    beforeEach(async () => {
-        dir = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-dl-'));
-        dest = path.join(dir, 'model.gguf.download');
-    });
-    afterEach(async () => { await fs.remove(dir); });
-    it('downloads the full body and hashes it', async () => {
-        const { get } = server({ etag: '"abc"' });
-        const result = await downloadToFile('https://host/model', dest, { get });
-        expect(await fs.readFile(dest)).toEqual(PAYLOAD);
-        expect(result).toEqual({ sha256: sha(PAYLOAD), bytes: PAYLOAD.length, etag: '"abc"' });
-    });
-    it('follows redirects and keeps the x-linked-etag from the first hop', async () => {
-        const { get: origin, calls } = server();
-        const get = async (url, headers, timeout) => {
-            if (url === 'https://hub/model') {
-                return response(302, Buffer.alloc(0), { location: 'https://cdn/model', 'x-linked-etag': '"lfs-sha"' });
-            }
-            return origin(url, headers, timeout);
-        };
-        const result = await downloadToFile('https://hub/model', dest, { get });
-        expect(calls.map(c => c.url)).toEqual(['https://cdn/model']);
-        expect(result.etag).toBe('"lfs-sha"');
-    });
-    it('resumes a partial file with a Range request and hashes the whole file', async () => {
-        await fs.writeFile(dest, PAYLOAD.subarray(0, 10));
-        const { get, calls } = server();
-        const result = await downloadToFile('https://host/model', dest, { get });
-        expect(calls[0].headers.Range).toBe('bytes=10-');
-        expect(await fs.readFile(dest)).toEqual(PAYLOAD);
-        expect(result.sha256).toBe(sha(PAYLOAD));
-        expect(result.bytes).toBe(PAYLOAD.length);
-    });
-    it('restarts from zero when the server ignores Range', async () => {
-        await fs.writeFile(dest, Buffer.from('stale-bytes'));
-        const { get } = server({ honourRange: false });
-        const result = await downloadToFile('https://host/model', dest, { get });
-        expect(await fs.readFile(dest)).toEqual(PAYLOAD);
-        expect(result.sha256).toBe(sha(PAYLOAD));
-    });
-    it('restarts when the partial is already past the end (416)', async () => {
-        await fs.writeFile(dest, Buffer.concat([PAYLOAD, Buffer.from('extra')]));
-        const { get, calls } = server();
-        await downloadToFile('https://host/model', dest, { get });
-        expect(calls).toHaveLength(2);
-        expect(await fs.readFile(dest)).toEqual(PAYLOAD);
-    });
-    it('rejects non-success responses without creating the file', async () => {
-        const get = async () => response(401);
-        await expect(downloadToFile('https://host/model', dest, { get })).rejects.toThrow('HTTP 401');
-        expect(await fs.pathExists(dest)).toBe(false);
-    });
-    it('refuses non-https URLs, including redirects to them', async () => {
-        const { get } = server();
-        await expect(downloadToFile('http://host/model', dest, { get })).rejects.toThrow('non-https');
-        const redirecting = async () => response(302, Buffer.alloc(0), { location: 'http://evil/model' });
-        await expect(downloadToFile('https://host/model', dest, { get: redirecting })).rejects.toThrow('non-https');
-    });
-    it('stops after too many redirects', async () => {
-        const loop = async (url) => response(302, Buffer.alloc(0), { location: `${url}x` });
-        await expect(downloadToFile('https://host/m', dest, { get: loop })).rejects.toThrow('Too many redirects');
-    });
-    it('aborts a stalled body and keeps the partial for the next resume', async () => {
-        const body = new PassThrough();
-        body.write(PAYLOAD.subarray(0, 5));
-        const get = async () => response(200, body, { 'content-length': String(PAYLOAD.length) });
-        await expect(downloadToFile('https://host/model', dest, { get, stallTimeoutMs: 50 })).rejects.toThrow('stalled');
-        // The partial file is kept for the next resume (how many bytes reached disk is up to the OS).
-        expect(await fs.pathExists(dest)).toBe(true);
-        expect((await fs.stat(dest)).size).toBeLessThanOrEqual(5);
-    });
-    it('reports progress against the full size when resuming', async () => {
-        await fs.writeFile(dest, PAYLOAD.subarray(0, 10));
-        const { get } = server();
-        const seen = [];
-        await downloadToFile('https://host/model', dest, { get, onProgress: (d, t) => seen.push([d, t]) });
-        expect(seen.at(-1)).toEqual([PAYLOAD.length, PAYLOAD.length]);
-    });
-});

package/dist/inference/llama-engine-checksum.test.d.ts

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

package/dist/inference/llama-engine-checksum.test.js

@@ -1,27 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { Readable } from 'stream';
-import { afterAll, describe, expect, it, vi } from 'vitest';
-/** Install into a scratch folder: the real one is ~/.rigour. */
-const home = vi.hoisted(() => {
-    const p = require('path');
-    return p.join(require('os').tmpdir(), `rigour-engine-${process.pid}`);
-});
-vi.mock('../storage/db.js', async (importOriginal) => ({ ...(await importOriginal()), RIGOUR_DIR: home }));
-const { installLlamaEngine, managedEngineDir, releaseAssetFor } = await import('./llama-engine.js');
-afterAll(() => fs.rmSync(home, { recursive: true, force: true }));
-describe('llama.cpp engine install', () => {
-    it('pins a checksum for every published platform', () => {
-        for (const key of ['darwin-arm64', 'darwin-x64', 'linux-x64', 'win32-x64']) {
-            expect(releaseAssetFor(key)?.sha256).toMatch(/^[0-9a-f]{64}$/);
-        }
-        expect(releaseAssetFor('linux-arm64')).toBeUndefined();
-    });
-    it.runIf(releaseAssetFor(`${os.platform()}-${os.arch()}`))('refuses an archive that does not match its pinned checksum, and installs nothing', async () => {
-        const tampered = async () => ({ statusCode: 200, headers: {}, body: Readable.from([Buffer.from('not the real llama.cpp archive')]) });
-        await expect(installLlamaEngine(undefined, tampered)).rejects.toThrow(/does not match its pinned checksum/);
-        expect(fs.existsSync(managedEngineDir())).toBe(false);
-        expect(fs.readdirSync(path.dirname(managedEngineDir())).filter(f => f.endsWith('.zip'))).toEqual([]);
-    });
-});

package/dist/inference/llama-engine.test.d.ts

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

package/dist/inference/llama-engine.test.js

@@ -1,51 +0,0 @@
-import fs from 'fs-extra';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { installBinFolder, llamaBinaryName, probeBinary, resetProbeCache } from './llama-engine.js';
-const isWindows = process.platform === 'win32';
-async function writeScript(file, body) {
-    await fs.outputFile(file, `#!/bin/sh\n${body}\n`);
-    await fs.chmod(file, 0o755);
-}
-describe.skipIf(isWindows)('probeBinary', () => {
-    let dir;
-    beforeEach(async () => {
-        dir = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-engine-'));
-        resetProbeCache();
-    });
-    afterEach(async () => { await fs.remove(dir); });
-    it('accepts a binary that reports its version', async () => {
-        const bin = path.join(dir, 'llama-cli');
-        await writeScript(bin, 'echo "version: 5604 (228f34c9)" >&2; exit 0');
-        expect(await probeBinary(bin)).toEqual({ ok: true, version: '5604' });
-    });
-    it('rejects the placeholder brain script', async () => {
-        const bin = path.join(dir, 'rigour-brain');
-        await writeScript(bin, 'echo "rigour-brain is a placeholder." >&2; exit 1');
-        const result = await probeBinary(bin);
-        expect(result.ok).toBe(false);
-        expect(result.error).toContain('placeholder');
-    });
-    it('rejects a missing binary', async () => {
-        expect((await probeBinary(path.join(dir, 'nope'))).ok).toBe(false);
-    });
-});
-describe('installBinFolder', () => {
-    let dir;
-    beforeEach(async () => { dir = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-engine-')); });
-    afterEach(async () => { await fs.remove(dir); });
-    it('installs the binary together with the shared libraries next to it', async () => {
-        const extracted = path.join(dir, 'extract', 'build', 'bin');
-        await fs.outputFile(path.join(extracted, llamaBinaryName()), 'bin');
-        await fs.outputFile(path.join(extracted, 'libllama.dylib'), 'lib');
-        await fs.outputFile(path.join(extracted, 'ggml-metal.metal'), 'metal');
-        const installDir = path.join(dir, 'llama-b5604');
-        await installBinFolder(path.join(dir, 'extract'), installDir);
-        expect((await fs.readdir(installDir)).sort()).toEqual(['ggml-metal.metal', 'libllama.dylib', llamaBinaryName()].sort());
-    });
-    it('fails clearly when the archive has no llama-cli', async () => {
-        await fs.outputFile(path.join(dir, 'extract', 'README.md'), 'x');
-        await expect(installBinFolder(path.join(dir, 'extract'), path.join(dir, 'out'))).rejects.toThrow('not found');
-    });
-});

package/dist/inference/llama-process.test.d.ts

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

package/dist/inference/llama-process.test.js

@@ -1,61 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildLlamaArgs, cleanLlamaOutput, contextSizeFor, runProcess } from './llama-process.js';
-const base = { modelPath: '/m.gguf', prompt: 'hello', maxTokens: 1024, threads: 4, temperature: 0.1 };
-describe('buildLlamaArgs', () => {
-    it('uses flags llama.cpp b5604 accepts and that keep generated text on stdout', () => {
-        const args = buildLlamaArgs(base);
-        expect(args).toContain('-st');
-        expect(args).toContain('--simple-io');
-        expect(args).toContain('--no-display-prompt');
-        expect(args).not.toContain('--json');
-        expect(args).not.toContain('--log-disable');
-    });
-    it('fixes the seed so a run is reproducible', () => {
-        const args = buildLlamaArgs(base);
-        expect(args[args.indexOf('--seed') + 1]).toBe('42');
-    });
-    it('constrains output with the findings schema file when given', () => {
-        const args = buildLlamaArgs({ ...base, schemaPath: '/schema.json' });
-        expect(args.slice(-2)).toEqual(['--json-schema-file', '/schema.json']);
-        expect(buildLlamaArgs(base)).not.toContain('--json-schema-file');
-    });
-    it('passes a context size that fits the prompt', () => {
-        const args = buildLlamaArgs({ ...base, prompt: 'x'.repeat(30_000) });
-        expect(Number(args[args.indexOf('--ctx-size') + 1])).toBe(contextSizeFor('x'.repeat(30_000), 1024));
-    });
-});
-describe('contextSizeFor', () => {
-    it('never goes below the 4096 default', () => {
-        expect(contextSizeFor('short', 512)).toBe(4096);
-    });
-    it('grows with the prompt, rounded up to 1024', () => {
-        const size = contextSizeFor('x'.repeat(30_000), 1024);
-        expect(size).toBeGreaterThanOrEqual(10_000 + 1024);
-        expect(size % 1024).toBe(0);
-    });
-    it('is capped at the model training context', () => {
-        expect(contextSizeFor('x'.repeat(1_000_000), 1024)).toBe(32768);
-    });
-});
-describe('cleanLlamaOutput', () => {
-    it('strips the end-of-generation marker', () => {
-        expect(cleanLlamaOutput('{"findings": []} [end of text]\n\n')).toBe('{"findings": []}');
-    });
-});
-describe('runProcess', () => {
-    it('collects stdout and stderr and returns the exit code', async () => {
-        const result = await runProcess(process.execPath, ['-e', 'process.stdout.write("out");process.stderr.write("err");process.exit(3)'], { timeoutMs: 10_000 });
-        expect(result).toEqual({ code: 3, stdout: 'out', stderr: 'err' });
-    });
-    it('runs with stdin closed so an interactive binary cannot wait on it', async () => {
-        const result = await runProcess(process.execPath, ['-e', 'process.stdin.on("end",()=>process.stdout.write("eof")).resume()'], { timeoutMs: 10_000 });
-        expect(result.stdout).toBe('eof');
-    });
-    it('kills and rejects on timeout', async () => {
-        await expect(runProcess(process.execPath, ['-e', 'setTimeout(()=>{}, 10_000)'], { timeoutMs: 100 }))
-            .rejects.toThrow('timed out');
-    });
-    it('rejects when the binary cannot be spawned', async () => {
-        await expect(runProcess('/nonexistent/llama-cli', [], { timeoutMs: 1_000 })).rejects.toThrow();
-    });
-});

package/dist/inference/local-model.test.d.ts

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

package/dist/inference/local-model.test.js

@@ -1,23 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { localModel } from './sidecar-provider.js';
-let dir;
-afterEach(() => { if (dir)
-    fs.rmSync(dir, { recursive: true, force: true }); dir = undefined; });
-describe('a local GGUF for --model-path', () => {
-    it('is used as is, never reported as a fallback', async () => {
-        dir = fs.mkdtempSync(path.join(os.tmpdir(), 'local-model-'));
-        const file = path.join(dir, 'rigour-max-candidate-q4_k_m.gguf');
-        fs.writeFileSync(file, Buffer.alloc(2_000_000));
-        expect(await localModel('max', file)).toEqual({
-            path: file, fallback: false,
-            info: { tier: 'max', name: 'rigour-max-candidate-q4_k_m.gguf (local)', filename: 'rigour-max-candidate-q4_k_m.gguf', url: '', sizeBytes: 2_000_000, sizeHuman: '2MB' },
-        });
-    });
-    it('fails clearly when the file is missing, rather than downloading something else', async () => {
-        const missing = path.resolve('/nonexistent/model.gguf'); // D:\\nonexistent\\model.gguf on Windows
-        await expect(localModel('max', missing)).rejects.toThrow(`Model file not found: ${missing}`);
-    });
-});

package/dist/inference/model-download.test.d.ts

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

package/dist/inference/model-download.test.js

@@ -1,125 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { createHash } from 'crypto';
-import { Readable } from 'stream';
-import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest';
-const home = vi.hoisted(() => {
-    const p = require('path');
-    const o = require('os');
-    return p.join(o.tmpdir(), `rigour-models-${process.pid}-${Date.now()}`);
-});
-vi.mock('../storage/db.js', () => ({ RIGOUR_DIR: home }));
-const { checkForUpdates, downloadModel, getCachedModel, normalizeModelVersion } = await import('./model-manager.js');
-const { FALLBACK_MODELS, MODELS } = await import('./types.js');
-const modelsDir = path.join(home, 'models');
-const PAYLOAD = Buffer.from('gguf-model-bytes');
-const PAYLOAD_SHA = createHash('sha256').update(PAYLOAD).digest('hex');
-function ok(body, sha) {
-    return Promise.resolve({ statusCode: 200, headers: { 'x-linked-etag': `"${sha}"` }, body: Readable.from([body]) });
-}
-const unauthorized = Promise.resolve({ statusCode: 401, headers: {}, body: Readable.from([]) });
-describe('downloadModel', () => {
-    beforeEach(async () => {
-        await fs.remove(home);
-        // A fresh version check: no network call to Hugging Face.
-        await fs.outputJson(path.join(modelsDir, '.latest_version.json'), { format: 2, version: '5', checkedAt: new Date().toISOString() });
-    });
-    afterAll(async () => { await fs.remove(home); });
-    it('falls back to the stock model when the fine-tuned model is unavailable, and says so', async () => {
-        const requested = [];
-        const get = (url) => {
-            requested.push(url);
-            return url.includes('rigour-labs/') ? unauthorized : ok(PAYLOAD, PAYLOAD_SHA);
-        };
-        const messages = [];
-        const modelPath = await downloadModel('lite', m => messages.push(m), get);
-        expect(requested).toEqual([MODELS.lite.url, FALLBACK_MODELS.lite.url]);
-        expect(path.basename(modelPath)).toBe(FALLBACK_MODELS.lite.filename);
-        expect(messages.some(m => m.includes('Fine-tuned model unavailable (HTTP 401'))).toBe(true);
-        const meta = await fs.readJson(`${modelPath}.meta.json`);
-        expect(meta).toMatchObject({ sha256: PAYLOAD_SHA, sizeBytes: PAYLOAD.length, sourceUrl: FALLBACK_MODELS.lite.url });
-    });
-    it('retries the fine-tuned model once a day when only the stock fallback is cached', async () => {
-        const failing = (url) => (url.includes('rigour-labs/') ? unauthorized : ok(PAYLOAD, PAYLOAD_SHA));
-        const stockPath = await downloadModel('lite', undefined, failing);
-        const requested = [];
-        const again = await downloadModel('lite', undefined, (url) => { requested.push(url); return unauthorized; });
-        expect(requested).toEqual([]); // failed less than a day ago: keep the fallback, no request
-        expect(again).toBe(stockPath);
-        await fs.writeJson(path.join(modelsDir, '.fine-tuned-unavailable-lite.json'), { failedAt: '2000-01-01T00:00:00Z', url: MODELS.lite.url });
-        const fineTuned = await downloadModel('lite', undefined, (url) => { requested.push(url); return ok(PAYLOAD, PAYLOAD_SHA); });
-        expect(requested).toEqual([MODELS.lite.url]);
-        expect(path.basename(fineTuned)).toBe(MODELS.lite.filename);
-        expect(await fs.pathExists(path.join(modelsDir, '.fine-tuned-unavailable-lite.json'))).toBe(false);
-    });
-    it('rejects a checksum mismatch and deletes the partial download', async () => {
-        const get = () => ok(PAYLOAD, 'f'.repeat(64));
-        await expect(downloadModel('lite', undefined, get)).rejects.toThrow('Checksum mismatch');
-        expect(await fs.pathExists(path.join(modelsDir, `${FALLBACK_MODELS.lite.filename}.download`))).toBe(false);
-        expect(await fs.pathExists(path.join(modelsDir, FALLBACK_MODELS.lite.filename))).toBe(false);
-    });
-});
-describe('getCachedModel', () => {
-    beforeEach(async () => { await fs.remove(home); });
-    async function cacheFile(filename, sizeBytes) {
-        const file = path.join(modelsDir, filename);
-        await fs.ensureDir(modelsDir);
-        await fs.writeFile(file, '');
-        await fs.truncate(file, sizeBytes); // sparse: no real disk use
-        await fs.writeJson(`${file}.meta.json`, {
-            sha256: 'a'.repeat(64), sizeBytes, verifiedAt: new Date(Date.now() + 1000).toISOString(), sourceUrl: 'https://x',
-        });
-    }
-    it('returns null when nothing is cached', async () => {
-        expect(await getCachedModel('deep')).toBeNull();
-    });
-    it('reports the stock fallback when only it is cached', async () => {
-        await cacheFile(FALLBACK_MODELS.deep.filename, FALLBACK_MODELS.deep.sizeBytes);
-        const cached = await getCachedModel('deep');
-        expect(cached).toMatchObject({ fallback: true, info: { filename: FALLBACK_MODELS.deep.filename } });
-    });
-    it('accepts a verified fine-tuned file smaller than the size estimate', async () => {
-        await cacheFile(MODELS.lite.filename, 397_807_360); // the published v5 lite model
-        expect(await getCachedModel('lite')).toMatchObject({ fallback: false, info: { filename: MODELS.lite.filename } });
-    });
-    it('accepts a file verified within the same millisecond it was written', async () => {
-        const file = path.join(modelsDir, FALLBACK_MODELS.deep.filename);
-        await cacheFile(FALLBACK_MODELS.deep.filename, 10);
-        const written = new Date('2026-01-01T00:00:00.000Z');
-        await fs.utimes(file, written, written.getTime() / 1000 + 0.0007); // mtime 0.7 ms into the same millisecond
-        await fs.writeJson(`${file}.meta.json`, { sha256: 'a'.repeat(64), sizeBytes: 10, verifiedAt: written.toISOString(), sourceUrl: 'https://x' });
-        expect(await getCachedModel('deep')).toMatchObject({ fallback: true });
-    });
-    it('rejects a file modified after it was verified', async () => {
-        const file = path.join(modelsDir, FALLBACK_MODELS.deep.filename);
-        await cacheFile(FALLBACK_MODELS.deep.filename, 10);
-        await fs.writeJson(`${file}.meta.json`, { sha256: 'a'.repeat(64), sizeBytes: 10, verifiedAt: '2000-01-01T00:00:00.000Z', sourceUrl: 'https://x' });
-        expect(await getCachedModel('deep')).toBeNull();
-    });
-    it('ignores a file without verified metadata', async () => {
-        await fs.ensureDir(modelsDir);
-        await fs.writeFile(path.join(modelsDir, FALLBACK_MODELS.deep.filename), 'partial');
-        expect(await getCachedModel('deep')).toBeNull();
-    });
-});
-describe('model versions', () => {
-    beforeEach(async () => { await fs.remove(home); vi.unstubAllGlobals(); });
-    it('keeps published version strings as they are', () => {
-        expect(normalizeModelVersion(5)).toBe('5');
-        expect(normalizeModelVersion('5')).toBe('5');
-        expect(normalizeModelVersion('v2.1.0')).toBe('2.1.0');
-        expect(normalizeModelVersion('5.0')).toBeNull();
-        expect(normalizeModelVersion({})).toBeNull();
-    });
-    it('names the published v5 repositories by default', () => {
-        expect(MODELS.lite.url).toBe('https://huggingface.co/rigour-labs/rigour-lite-v5-gguf/resolve/main/rigour-lite-v5-q4_k_m.gguf');
-        expect(MODELS.deep.url).toBe('https://huggingface.co/rigour-labs/rigour-deep-v5-gguf/resolve/main/rigour-deep-v5-q4_k_m.gguf');
-    });
-    it('ignores a version cache from the old SemVer conversion and re-reads the published version', async () => {
-        await fs.outputJson(path.join(modelsDir, '.latest_version.json'), { version: '5.0.0', checkedAt: new Date().toISOString() });
-        vi.stubGlobal('fetch', vi.fn(async () => ({ ok: true, json: async () => ({ version: 5 }) })));
-        expect(await checkForUpdates()).toBe('5');
-        expect(await fs.readJson(path.join(modelsDir, '.latest_version.json'))).toMatchObject({ format: 2, version: '5' });
-        expect(MODELS.deep.filename).toBe('rigour-deep-v5-q4_k_m.gguf');
-    });
-});

package/dist/inference/model-manager.test.d.ts

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

package/dist/inference/model-manager.test.js

@@ -1,24 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import fs from 'fs-extra';
-import os from 'os';
-import path from 'path';
-import { extractSha256FromEtag, hashFileSha256 } from './model-manager.js';
-describe('model manager integrity helpers', () => {
-    it('extracts sha256 digest from a strong ETag', () => {
-        const digest = 'a'.repeat(64);
-        expect(extractSha256FromEtag(`"${digest}"`)).toBe(digest);
-        expect(extractSha256FromEtag(`W/"${digest}"`)).toBe(digest);
-    });
-    it('returns null for non-sha ETags', () => {
-        expect(extractSha256FromEtag('"not-a-digest"')).toBeNull();
-        expect(extractSha256FromEtag(null)).toBeNull();
-    });
-    it('hashes file contents with sha256', async () => {
-        const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-model-hash-'));
-        const filePath = path.join(dir, 'sample.gguf');
-        await fs.writeFile(filePath, 'rigour-model-check');
-        const digest = await hashFileSha256(filePath);
-        expect(digest).toBe('e123266ea4b37a81948a0a844dd58eddfc81737aa6fdf9dafc818fd23bae75f0');
-        await fs.remove(dir);
-    });
-});

package/dist/inference/types.test.d.ts

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

package/dist/inference/types.test.js

@@ -1,19 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildModelInfo, FALLBACK_MODELS, localTier, MODELS } from './types.js';
-describe('local model tiers', () => {
-    it('picks max over pro over the lite default', () => {
-        expect(localTier({})).toBe('lite');
-        expect(localTier({ pro: true })).toBe('deep');
-        expect(localTier({ max: true })).toBe('max');
-        expect(localTier({ max: true, pro: true })).toBe('max');
-    });
-    it('asks for a published max fine-tune and falls back to the stock 7B coder model', () => {
-        expect(buildModelInfo('max', '6.0.0').url)
-            .toBe('https://huggingface.co/rigour-labs/rigour-max-v6.0.0-gguf/resolve/main/rigour-max-v6.0.0-q4_k_m.gguf');
-        expect(MODELS.max.tier).toBe('max');
-        expect(FALLBACK_MODELS.max).toMatchObject({
-            filename: 'qwen2.5-coder-7b-instruct-q4_k_m.gguf',
-            url: 'https://huggingface.co/Qwen/Qwen2.5-Coder-7B-Instruct-GGUF/resolve/main/qwen2.5-coder-7b-instruct-q4_k_m.gguf',
-        });
-    });
-});

package/dist/memory/recall.test.d.ts

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

package/dist/memory/recall.test.js

@@ -1,36 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { RECALL_LIMIT, rankMemories } from './recall.js';
-const memories = [
-    { scope: 'repo', key: 'retry_policy', value: 'Wrap network calls in withRetry from lib/net; never hand-roll backoff.' },
-    { scope: 'repo', key: 'db_access', value: 'Reports read from the replica, never the primary.' },
-    { scope: 'user', key: 'pr_size', value: 'Keep pull requests under 400 lines.' },
-];
-/** A stand-in embedding: one dimension per topic word, so similarity is predictable. */
-const TOPICS = ['retry', 'backoff', 'network', 'replica', 'report', 'pull', 'request'];
-const embed = async (text) => TOPICS.map(topic => (text.toLowerCase().includes(topic) ? 1 : 0));
-describe('rankMemories', () => {
-    it('returns the memories that match by meaning, best first, above the floor', async () => {
-        const ranked = await rankMemories('add exponential backoff to a flaky network call', memories, embed);
-        expect(ranked.map(m => [m.key, m.match])).toEqual([['retry_policy', 'semantic']]);
-    });
-    it('returns nothing rather than the closest weak match', async () => {
-        expect(await rankMemories('rename a css class', memories, embed)).toEqual([]);
-    });
-    it('falls back to keyword overlap when the model is unavailable, and says so', async () => {
-        const ranked = await rankMemories('replica reports', memories, async () => []);
-        expect(ranked.map(m => [m.key, m.match])).toEqual([['db_access', 'keyword']]);
-    });
-    it(`returns at most ${RECALL_LIMIT}`, async () => {
-        const many = Array.from({ length: 10 }, (_, i) => ({ scope: 'repo', key: `retry_${i}`, value: 'network retry backoff' }));
-        expect(await rankMemories('network retry backoff', many, embed)).toHaveLength(RECALL_LIMIT);
-    });
-    it('embeds each text once, not on every recall', async () => {
-        let calls = 0;
-        const counting = async (text) => { calls++; return embed(text); };
-        const fresh = memories.map(m => ({ ...m, value: `${m.value} (cache test)` }));
-        await rankMemories('network retry', fresh, counting);
-        const first = calls;
-        await rankMemories('replica reports', fresh, counting);
-        expect(calls - first).toBe(1); // only the new query
-    });
-});

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

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