@rigour-labs/core 6.2.4 → 6.3.0

package/dist/inference/sidecar-provider.js

@@ -1,20 +1,26 @@
 /**
- * Sidecar Binary Provider — runs inference via pre-compiled llama.cpp binary.
- * Auto-downloads llama-cli from GitHub releases on first use.
- * Falls back to npm packages or PATH lookup for development/manual installs.
+ * Sidecar provider: local inference with llama.cpp's llama-cli.
+ *
+ * Engine resolution, first binary that passes `--version` wins:
+ *   1. managed install of the pinned release (~/.rigour/bin/llama-<tag>/)
+ *   2. legacy locations: ~/.rigour/bin/llama-cli, @rigour-labs/brain-<platform>
+ *   3. llama-cli on PATH
+ * If none runs, the pinned release is downloaded and installed.
+ *
+ * Code never leaves the machine: prompts go to a local child process.
  */
-import { execFile } from 'child_process';
-import { promisify } from 'util';
+import crypto from 'crypto';
 import path from 'path';
 import os from 'os';
 import fs from 'fs-extra';
 import { createRequire } from 'module';
-import { ensureModel, isModelCached, getModelInfo } from './model-manager.js';
+import { ensureModel, getCachedModel } from './model-manager.js';
 import { ensureExecutableBinary } from './executable.js';
-const execFileAsync = promisify(execFile);
-const SIDECAR_INSTALL_DIR = path.join(os.homedir(), '.rigour', 'sidecar');
-const BINARY_DIR = path.join(os.homedir(), '.rigour', 'bin');
-/** Platform → npm package mapping (legacy, still checked) */
+import { installLlamaEngine, llamaBinaryName, managedEngineDir, managedEnginePath, probeBinary } from './llama-engine.js';
+import { buildLlamaArgs, cleanLlamaOutput, FINDINGS_JSON_SCHEMA, ProcessTimeoutError, runProcess } from './llama-process.js';
+import { RIGOUR_DIR } from '../storage/db.js';
+const DEFAULT_TIMEOUT_MS = 60_000;
+/** Platform → legacy npm package that may carry a rigour-brain binary. */
 const PLATFORM_PACKAGES = {
     'darwin-arm64': '@rigour-labs/brain-darwin-arm64',
     'darwin-x64': '@rigour-labs/brain-darwin-x64',
@@ -22,374 +28,151 @@ const PLATFORM_PACKAGES = {
     'linux-arm64': '@rigour-labs/brain-linux-arm64',
     'win32-x64': '@rigour-labs/brain-win-x64',
 };
-const LLAMA_RELEASE_TAG = 'b5604';
-const LLAMA_RELEASE_BASE = `https://github.com/ggml-org/llama.cpp/releases/download/${LLAMA_RELEASE_TAG}`;
-/** Platform → llama.cpp release asset name */
-const LLAMA_RELEASE_ASSETS = {
-    'darwin-arm64': `llama-${LLAMA_RELEASE_TAG}-bin-macos-arm64.zip`,
-    'darwin-x64': `llama-${LLAMA_RELEASE_TAG}-bin-macos-x64.zip`,
-    'linux-x64': `llama-${LLAMA_RELEASE_TAG}-bin-ubuntu-x64.zip`,
-    'win32-x64': `llama-${LLAMA_RELEASE_TAG}-bin-win-cpu-x64.zip`,
-    // linux-arm64 not published by llama.cpp — users must build from source or use cloud provider
-};
 export class SidecarProvider {
     name = 'sidecar';
     binaryPath = null;
-    modelPath = null;
+    model = null;
+    schemaPath = null;
     tier;
     threads;
     constructor(tier = 'lite', threads = 4) {
         this.tier = tier;
         this.threads = threads;
     }
+    /** True when a llama-cli that actually runs is installed. */
     async isAvailable() {
+        return (await this.findEngine()) !== null;
+    }
+    /** The llama-cli this provider would use and its version, or null if none runs. */
+    async findEngine() {
         const binary = await this.resolveBinaryPath();
-        return binary !== null;
+        if (!binary)
+            return null;
+        return { path: binary, version: (await probeBinary(binary)).version };
+    }
+    /** Install the engine and model for this tier without running inference. */
+    async prepare(onProgress) {
+        await this.setup(onProgress);
+        this.dispose();
     }
     async setup(onProgress) {
-        // 1. Check/resolve binary
-        this.binaryPath = await this.resolveBinaryPath();
-        // Auto-bootstrap: download llama-cli directly from GitHub releases
-        if (!this.binaryPath) {
-            const downloaded = await this.downloadLlamaCli(onProgress);
-            if (downloaded) {
-                this.binaryPath = await this.resolveBinaryPath();
-            }
-        }
-        // Legacy fallback: try npm package install
-        if (!this.binaryPath) {
-            const packageName = this.getPlatformPackageName();
-            if (packageName) {
-                const installed = await this.installSidecarBinary(packageName, onProgress);
-                if (installed) {
-                    this.binaryPath = await this.resolveBinaryPath();
-                }
-            }
-        }
-        if (!this.binaryPath) {
-            onProgress?.('⚠ Inference engine not found. Rigour will auto-download on next attempt.');
-            throw new Error(`Sidecar binary not found. Check network connection and retry.`);
-        }
-        let executableCheck = ensureExecutableBinary(this.binaryPath);
-        // If the discovered binary is not executable, try a managed reinstall once.
-        const retryPackage = this.getPlatformPackageName();
-        if (!executableCheck.ok && retryPackage) {
-            onProgress?.('⚠ Inference engine is present but not executable. Reinstalling managed sidecar...');
-            const installed = await this.installSidecarBinary(retryPackage, onProgress);
-            if (installed) {
-                const refreshedPath = await this.resolveBinaryPath();
-                if (refreshedPath) {
-                    this.binaryPath = refreshedPath;
-                    executableCheck = ensureExecutableBinary(this.binaryPath);
-                }
-            }
-        }
-        if (!executableCheck.ok) {
-            throw new Error(`Sidecar binary is not executable: ${this.binaryPath}. Run: chmod +x "${this.binaryPath}"`);
-        }
-        if (executableCheck.fixed) {
-            onProgress?.('✓ Fixed execute permission for inference engine');
-        }
+        this.binaryPath = await this.resolveBinaryPath() ?? await installLlamaEngine(onProgress);
         onProgress?.('✓ Inference engine ready');
-        // 2. Ensure model is downloaded
-        if (!(await isModelCached(this.tier))) {
-            const modelInfo = getModelInfo(this.tier);
-            onProgress?.(`⬇ Downloading analysis model (${modelInfo.sizeHuman})...`);
-        }
-        this.modelPath = await ensureModel(this.tier, (msg, percent) => {
-            if (percent !== undefined && percent < 100) {
+        await ensureModel(this.tier, (msg, percent) => {
+            if (percent !== undefined && percent < 100)
                 onProgress?.(`  ${msg}`);
-            }
         });
+        this.model = await getCachedModel(this.tier);
+        if (!this.model) {
+            throw new Error(`Model for tier "${this.tier}" is not cached after download.`);
+        }
+        if (this.model.fallback) {
+            onProgress?.(`  Using stock model ${this.model.info.name} (fine-tuned model not available).`);
+        }
+        this.schemaPath = await writeFindingsSchema();
         onProgress?.('✓ Model ready');
     }
+    /** The model file setup() loaded, or null before setup. */
+    getActiveModel() {
+        if (!this.model)
+            return null;
+        return { name: this.model.info.name, filename: this.model.info.filename, fallback: this.model.fallback };
+    }
     async analyze(prompt, options) {
-        if (!this.binaryPath || !this.modelPath) {
+        if (!this.binaryPath || !this.model) {
             throw new Error('Provider not set up. Call setup() first.');
         }
-        const args = [
-            '--model', this.modelPath,
-            '--prompt', prompt,
-            '--n-predict', String(options?.maxTokens || 512),
-            '--threads', String(this.threads),
-            '--temp', String(options?.temperature || 0.1),
-            '--no-display-prompt', // Don't echo the prompt
-            '--log-disable', // Suppress llama.cpp logging
-        ];
-        // JSON grammar constraint if available
-        if (options?.jsonMode) {
-            args.push('--json');
-        }
+        const timeoutMs = options?.timeout || DEFAULT_TIMEOUT_MS;
+        const args = buildLlamaArgs({
+            modelPath: this.model.path,
+            prompt,
+            maxTokens: options?.maxTokens || 1024,
+            threads: this.threads,
+            temperature: options?.temperature ?? 0.1,
+            schemaPath: options?.jsonSchema ? await schemaFileFor(options.jsonSchema) : options?.jsonMode ? this.schemaPath ?? undefined : undefined,
+        });
+        let result;
         try {
-            const execOptions = {
-                timeout: options?.timeout || 60000,
-                maxBuffer: 10 * 1024 * 1024, // 10MB
-                env: { ...process.env, LLAMA_LOG_DISABLE: '1' },
-            };
-            const runInference = async () => {
-                return process.platform === 'win32' && this.binaryPath.endsWith('.cmd')
-                    ? await execFileAsync('cmd.exe', ['/d', '/s', '/c', [this.binaryPath, ...args].map(quoteCmdArg).join(' ')], execOptions)
-                    : await execFileAsync(this.binaryPath, args, execOptions);
-            };
-            let stdout;
-            try {
-                ({ stdout } = await runInference());
-            }
-            catch (error) {
-                // One retry path for stale/bad file mode in packaged installs.
-                if (error?.code === 'EACCES') {
-                    const check = ensureExecutableBinary(this.binaryPath);
-                    if (check.ok) {
-                        ({ stdout } = await runInference());
-                    }
-                    else {
-                        const packageName = this.getPlatformPackageName();
-                        if (packageName) {
-                            const installed = await this.installSidecarBinary(packageName);
-                            if (installed) {
-                                const refreshedPath = await this.resolveBinaryPath();
-                                if (refreshedPath) {
-                                    this.binaryPath = refreshedPath;
-                                    const refreshedCheck = ensureExecutableBinary(this.binaryPath);
-                                    if (refreshedCheck.ok) {
-                                        ({ stdout } = await runInference());
-                                        return stdout.trim();
-                                    }
-                                }
-                            }
-                        }
-                        throw error;
-                    }
-                }
-                else {
-                    throw error;
-                }
-            }
-            // llama.cpp sometimes outputs to stderr for diagnostics — ignore
-            return stdout.trim();
+            result = await runProcess(this.binaryPath, args, { timeoutMs });
         }
         catch (error) {
-            if (error.killed) {
-                throw new Error(`Inference timed out after ${(options?.timeout || 60000) / 1000}s`);
-            }
-            if (error?.code === 'EACCES') {
-                throw new Error(`Inference binary is not executable: ${this.binaryPath}. Run: chmod +x "${this.binaryPath}"`);
-            }
-            throw new Error(`Inference failed: ${error.message}`);
+            if (error instanceof ProcessTimeoutError)
+                throw new Error(`Inference ${error.message}`);
+            throw new Error(`Inference failed: ${error?.message ?? String(error)}`);
         }
+        if (result.code !== 0) {
+            const detail = result.stderr.trim().split(/\r?\n/).slice(-3).join(' | ');
+            throw new Error(`Inference failed (exit ${result.code}): ${detail}`);
+        }
+        return cleanLlamaOutput(result.stdout);
     }
     dispose() {
-        // No persistent process to clean up
         this.binaryPath = null;
-        this.modelPath = null;
-    }
-    getPlatformKey() {
-        return `${os.platform()}-${os.arch()}`;
-    }
-    getPlatformPackageName() {
-        const platformKey = this.getPlatformKey();
-        return PLATFORM_PACKAGES[platformKey];
+        this.model = null;
     }
+    /** First candidate binary that exists, is executable and passes the probe. */
     async resolveBinaryPath() {
-        const platformKey = this.getPlatformKey();
-        // Strategy 0: Check ~/.rigour/bin/llama-cli (auto-downloaded from GitHub releases)
-        const binaryName = os.platform() === 'win32' ? 'llama-cli.exe' : 'llama-cli';
-        const autoDownloadedPath = path.join(BINARY_DIR, binaryName);
-        if (await fs.pathExists(autoDownloadedPath)) {
-            return autoDownloadedPath;
-        }
-        // Strategy 1: Check @rigour-labs/brain-{platform} optional dependency
-        const packageName = PLATFORM_PACKAGES[platformKey];
-        if (packageName) {
-            // Prefer Rigour-managed sidecar install root first to avoid brittle global/homebrew layouts.
-            const managedPath = path.join(SIDECAR_INSTALL_DIR, 'node_modules', ...packageName.split('/'), 'bin', 'rigour-brain');
-            const managedCandidates = os.platform() === 'win32'
-                ? [managedPath + '.exe', managedPath + '.cmd', managedPath]
-                : [managedPath];
-            for (const managedBinPath of managedCandidates) {
-                if (await fs.pathExists(managedBinPath)) {
-                    return managedBinPath;
-                }
-            }
-            try {
-                const require = createRequire(import.meta.url);
-                const pkgJsonPath = require.resolve(path.posix.join(packageName, 'package.json'));
-                const pkgDir = path.dirname(pkgJsonPath);
-                const resolvedBin = path.join(pkgDir, 'bin', 'rigour-brain');
-                const resolvedCandidates = os.platform() === 'win32'
-                    ? [resolvedBin + '.exe', resolvedBin + '.cmd', resolvedBin]
-                    : [resolvedBin];
-                for (const resolvedBinPath of resolvedCandidates) {
-                    if (await fs.pathExists(resolvedBinPath)) {
-                        return resolvedBinPath;
-                    }
-                }
-            }
-            catch {
-                // Package not resolvable from current runtime
-            }
-            try {
-                // Try to resolve from node_modules
-                const possiblePaths = [
-                    // From current working directory
-                    path.join(process.cwd(), 'node_modules', ...packageName.split('/'), 'bin', 'rigour-brain'),
-                    // From rigour-core node_modules
-                    path.join(__dirname, '..', '..', '..', 'node_modules', ...packageName.split('/'), 'bin', 'rigour-brain'),
-                    // From monorepo root when rigour-core is nested under packages/
-                    path.join(__dirname, '..', '..', '..', '..', '..', 'node_modules', ...packageName.split('/'), 'bin', 'rigour-brain'),
-                    // From global node_modules
-                    path.join(os.homedir(), '.npm-global', 'lib', 'node_modules', ...packageName.split('/'), 'bin', 'rigour-brain'),
-                ];
-                for (const p of possiblePaths) {
-                    const candidates = os.platform() === 'win32' ? [p + '.exe', p + '.cmd', p] : [p];
-                    for (const binPath of candidates) {
-                        if (await fs.pathExists(binPath)) {
-                            return binPath;
-                        }
-                    }
-                }
-            }
-            catch {
-                // Package not installed
-            }
-        }
-        // Strategy 2: Check ~/.rigour/bin/
-        const localBin = path.join(os.homedir(), '.rigour', 'bin', 'rigour-brain');
-        const localCandidates = os.platform() === 'win32'
-            ? [localBin + '.exe', localBin + '.cmd', localBin]
-            : [localBin];
-        for (const localBinPath of localCandidates) {
-            if (await fs.pathExists(localBinPath)) {
-                return localBinPath;
-            }
-        }
-        // Strategy 3: Check PATH for llama-cli (llama.cpp CLI)
-        const locator = os.platform() === 'win32' ? 'where' : 'which';
-        try {
-            const { stdout } = await execFileAsync(locator, ['llama-cli']);
-            const llamaPath = stdout.split(/\r?\n/).map(s => s.trim()).find(Boolean) || '';
-            if (llamaPath && await fs.pathExists(llamaPath)) {
-                return llamaPath;
-            }
-        }
-        catch {
-            // Not in PATH
-        }
-        // Strategy 4: Check for llama.cpp server-style binary names
-        const altNames = ['llama-cli', 'llama', 'main'];
-        for (const name of altNames) {
-            try {
-                const { stdout } = await execFileAsync(locator, [name]);
-                const resolved = stdout.split(/\r?\n/).map(s => s.trim()).find(Boolean);
-                if (resolved && await fs.pathExists(resolved))
-                    return resolved;
-            }
-            catch {
-                // Continue
-            }
+        for (const candidate of await this.candidateBinaries()) {
+            if (!(await fs.pathExists(candidate)))
+                continue;
+            if (!ensureExecutableBinary(candidate).ok)
+                continue;
+            if ((await probeBinary(candidate)).ok)
+                return candidate;
         }
         return null;
     }
-    /**
-     * Download llama-cli directly from llama.cpp GitHub releases.
-     * Extracts the binary to ~/.rigour/bin/llama-cli
-     */
-    async downloadLlamaCli(onProgress) {
-        const platformKey = this.getPlatformKey();
-        const assetName = LLAMA_RELEASE_ASSETS[platformKey];
-        if (!assetName)
-            return false;
-        const url = `${LLAMA_RELEASE_BASE}/${assetName}`;
-        const zipPath = path.join(BINARY_DIR, assetName);
-        const binaryName = os.platform() === 'win32' ? 'llama-cli.exe' : 'llama-cli';
-        const destPath = path.join(BINARY_DIR, binaryName);
-        // Already downloaded
-        if (await fs.pathExists(destPath))
-            return true;
-        onProgress?.(`⬇ Downloading inference engine (llama.cpp ${LLAMA_RELEASE_TAG})...`);
-        try {
-            await fs.ensureDir(BINARY_DIR);
-            // Download zip
-            const response = await fetch(url, { redirect: 'follow' });
-            if (!response.ok) {
-                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-            }
-            const buffer = Buffer.from(await response.arrayBuffer());
-            await fs.writeFile(zipPath, buffer);
-            onProgress?.('  Extracting...');
-            // Extract llama-cli from zip
-            if (os.platform() === 'win32') {
-                await execFileAsync('powershell', [
-                    '-Command',
-                    `Expand-Archive -Path "${zipPath}" -DestinationPath "${BINARY_DIR}/llama-extract" -Force`,
-                ], { timeout: 60000 });
-            }
-            else {
-                await execFileAsync('unzip', ['-o', zipPath, '-d', path.join(BINARY_DIR, 'llama-extract')], {
-                    timeout: 60000,
-                });
-            }
-            // Find llama-cli in extracted files
-            const extractDir = path.join(BINARY_DIR, 'llama-extract');
-            const llamaBin = await findFileRecursive(extractDir, binaryName);
-            if (!llamaBin) {
-                throw new Error(`${binaryName} not found in release archive`);
-            }
-            await fs.copy(llamaBin, destPath);
-            if (os.platform() !== 'win32') {
-                await fs.chmod(destPath, 0o755);
-            }
-            // Cleanup
-            await fs.remove(zipPath);
-            await fs.remove(extractDir);
-            onProgress?.(`✓ Inference engine ready (${LLAMA_RELEASE_TAG})`);
-            return true;
-        }
-        catch (error) {
-            const reason = typeof error?.message === 'string' ? error.message : 'unknown error';
-            onProgress?.(`⚠ Download failed: ${reason}`);
-            // Cleanup partial downloads
-            await fs.remove(zipPath).catch(() => { });
-            await fs.remove(path.join(BINARY_DIR, 'llama-extract')).catch(() => { });
-            return false;
-        }
+    async candidateBinaries() {
+        const candidates = [
+            managedEnginePath(),
+            path.join(RIGOUR_DIR, 'bin', llamaBinaryName()),
+            ...brainPackageBinaries(),
+        ];
+        const onPath = await findOnPath('llama-cli');
+        if (onPath)
+            candidates.push(onPath);
+        return candidates.filter((c, i) => candidates.indexOf(c) === i);
     }
-    /** Legacy: install via npm brain package */
-    async installSidecarBinary(packageName, onProgress) {
-        onProgress?.(`⬇ Trying npm fallback: ${packageName}`);
-        try {
-            await fs.ensureDir(SIDECAR_INSTALL_DIR);
-            await execFileAsync(os.platform() === 'win32' ? 'npm.cmd' : 'npm', ['install', '--no-save', '--no-package-lock', '--prefix', SIDECAR_INSTALL_DIR, packageName], {
-                cwd: SIDECAR_INSTALL_DIR,
-                timeout: 120000,
-                maxBuffer: 10 * 1024 * 1024,
-            });
-        }
-        catch (error) {
-            const reason = typeof error?.message === 'string' ? error.message : 'unknown install error';
-            onProgress?.(`⚠ npm install failed: ${reason}`);
-            return false;
-        }
-        onProgress?.(`✓ Installed ${packageName}`);
-        return true;
+}
+function brainPackageBinaries() {
+    const packageName = PLATFORM_PACKAGES[`${os.platform()}-${os.arch()}`];
+    if (!packageName)
+        return [];
+    const suffixes = os.platform() === 'win32' ? ['.exe', '.cmd', ''] : [''];
+    try {
+        const require = createRequire(import.meta.url);
+        const pkgDir = path.dirname(require.resolve(path.posix.join(packageName, 'package.json')));
+        return suffixes.map(s => path.join(pkgDir, 'bin', `rigour-brain${s}`));
+    }
+    catch {
+        return [];
     }
 }
-function quoteCmdArg(value) {
-    return `"${value.replace(/"/g, '\\"')}"`;
+async function findOnPath(name) {
+    const locator = os.platform() === 'win32' ? 'where' : 'which';
+    try {
+        const { code, stdout } = await runProcess(locator, [name], { timeoutMs: 5_000 });
+        if (code !== 0)
+            return null;
+        return stdout.split(/\r?\n/).map(s => s.trim()).find(Boolean) ?? null;
+    }
+    catch {
+        return null;
+    }
 }
-/** Recursively find a file by name in a directory */
-async function findFileRecursive(dir, filename) {
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            const found = await findFileRecursive(fullPath, filename);
-            if (found)
-                return found;
-        }
-        else if (entry.name === filename) {
-            return fullPath;
-        }
+/** A schema file per distinct schema, written once and reused across calls. */
+async function schemaFileFor(schema) {
+    const text = JSON.stringify(schema);
+    const schemaPath = path.join(managedEngineDir(), '..', 'schemas', `${crypto.createHash('sha256').update(text).digest('hex').slice(0, 16)}.json`);
+    if (!(await fs.pathExists(schemaPath))) {
+        await fs.ensureDir(path.dirname(schemaPath));
+        await fs.writeFile(schemaPath, text);
     }
-    return null;
+    return schemaPath;
+}
+async function writeFindingsSchema() {
+    const schemaPath = path.join(managedEngineDir(), '..', 'findings.schema.json');
+    await fs.ensureDir(path.dirname(schemaPath));
+    await fs.writeJson(schemaPath, FINDINGS_JSON_SCHEMA);
+    return schemaPath;
 }

package/dist/inference/types.d.ts

@@ -29,6 +29,8 @@ export interface InferenceOptions {
     temperature?: number;
     timeout?: number;
     jsonMode?: boolean;
+    /** Constrain local output to this JSON schema instead of the findings schema. */
+    jsonSchema?: Record<string, unknown>;
 }
 /**
  * A single finding from deep LLM analysis.

package/dist/semantic/ast.d.ts

@@ -0,0 +1,29 @@
+import ts from 'typescript';
+export type FunctionLike = ts.FunctionDeclaration | ts.FunctionExpression | ts.ArrowFunction | ts.MethodDeclaration;
+export declare function isFunctionLike(node: ts.Node): node is FunctionLike;
+/** Drop parentheses, type assertions, non-null and `await` around an expression. */
+export declare function unwrap(expr: ts.Expression): ts.Expression;
+/**
+ * Symbol for a node, following import aliases to the declaration. For the
+ * name in a shorthand property (`{ headers }`) this is the variable it reads,
+ * not the property it creates.
+ */
+export declare function symbolOf(checker: ts.TypeChecker, node: ts.Node): ts.Symbol | undefined;
+/** The function a call invokes, when it resolves to one declared in source. */
+export declare function calledFunction(checker: ts.TypeChecker, call: ts.CallExpression): FunctionLike | undefined;
+/** `fetch` in `fetch(...)`, `deps.fetch(...)`, `this.fetch(...)`. */
+export declare function calleeName(call: ts.CallExpression): string | undefined;
+export declare function enclosingFunction(node: ts.Node): FunctionLike | undefined;
+/** Visit every descendant of `root` that belongs to `root` itself, not to a nested function. */
+export declare function forEachOwnNode(root: ts.Node, visit: (node: ts.Node) => void): void;
+export declare function forEachNode(root: ts.Node, visit: (node: ts.Node) => void): void;
+/** Text of a property name (`a`, `'a'`, `"x-token"`), or undefined for computed names. */
+export declare function propertyNameText(name: ts.PropertyName | undefined): string | undefined;
+export declare function lineOf(node: ts.Node): number;
+/** "http.ts:51" style location for evidence, relative to cwd. */
+export declare function locationOf(cwd: string, node: ts.Node): string;
+export declare function relativeFile(cwd: string, sf: ts.SourceFile): string;
+/** Short, single-line source text for messages. */
+export declare function snippet(node: ts.Node, max?: number): string;
+/** True when any identifier inside `expr` resolves to `target`. */
+export declare function mentionsSymbol(checker: ts.TypeChecker, expr: ts.Node, target: ts.Symbol): boolean;