@rigour-labs/core 3.0.5 → 4.0.0

package/dist/gates/test-quality-lang.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Language-specific test quality checks for Go and Java/Kotlin.
+ * Extracted from test-quality.ts to keep it under 500 lines.
+ */
+export interface TestQualityIssue {
+    file: string;
+    line: number;
+    pattern: string;
+    reason: string;
+}
+export interface TestQualityConfig {
+    check_empty_tests?: boolean;
+    check_tautological?: boolean;
+    check_mock_heavy?: boolean;
+    max_mocks_per_test?: number;
+}
+/**
+ * Go test quality checks.
+ * Go tests use func TestXxx(t *testing.T) pattern.
+ * Assertions via t.Fatal, t.Error, t.Fatalf, t.Errorf, t.Fail, t.FailNow.
+ * Also checks for t.Run subtests and table-driven patterns.
+ */
+export declare function checkGoTestQuality(content: string, file: string, issues: TestQualityIssue[], config: TestQualityConfig): void;
+/**
+ * Java/Kotlin test quality checks.
+ * JUnit 4: @Test + Assert.assertEquals, assertTrue, etc.
+ * JUnit 5: @Test + Assertions.assertEquals, assertThrows, etc.
+ * Kotlin: @Test + kotlin.test assertEquals, etc.
+ */
+export declare function checkJavaKotlinTestQuality(content: string, file: string, ext: string, issues: TestQualityIssue[], config: TestQualityConfig): void;

package/dist/gates/test-quality-lang.js

@@ -0,0 +1,188 @@
+/**
+ * Language-specific test quality checks for Go and Java/Kotlin.
+ * Extracted from test-quality.ts to keep it under 500 lines.
+ */
+/**
+ * Go test quality checks.
+ * Go tests use func TestXxx(t *testing.T) pattern.
+ * Assertions via t.Fatal, t.Error, t.Fatalf, t.Errorf, t.Fail, t.FailNow.
+ * Also checks for t.Run subtests and table-driven patterns.
+ */
+export function checkGoTestQuality(content, file, issues, config) {
+    const lines = content.split('\n');
+    let inTestFunc = false;
+    let testStartLine = 0;
+    let braceDepth = 0;
+    let hasAssertion = false;
+    let testContent = '';
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Detect test function: func TestXxx(t *testing.T) {
+        const testMatch = trimmed.match(/^func\s+(Test\w+|Benchmark\w+)\s*\(/);
+        if (testMatch && !inTestFunc) {
+            inTestFunc = true;
+            testStartLine = i + 1;
+            braceDepth = 0;
+            hasAssertion = false;
+            testContent = '';
+            // Count braces on this line
+            for (const ch of line) {
+                if (ch === '{')
+                    braceDepth++;
+                if (ch === '}')
+                    braceDepth--;
+            }
+            continue;
+        }
+        if (inTestFunc) {
+            testContent += line + '\n';
+            for (const ch of line) {
+                if (ch === '{')
+                    braceDepth++;
+                if (ch === '}')
+                    braceDepth--;
+            }
+            // Go test assertions: t.Fatal, t.Error, t.Fatalf, t.Errorf, t.Fail, t.FailNow
+            // Also: assert/require from testify, t.Run for subtests
+            if (/\bt\.\s*(?:Fatal|Error|Fatalf|Errorf|Fail|FailNow|Log|Logf|Skip|Skipf|Helper)\s*\(/.test(line) ||
+                /\bt\.Run\s*\(/.test(line) ||
+                /\bassert\.\w+\s*\(/.test(line) || /\brequire\.\w+\s*\(/.test(line) ||
+                /\bif\b.*\bt\./.test(line)) {
+                hasAssertion = true;
+            }
+            // Tautological: if true { t.Fatal... } or assert.True(t, true)
+            if (config.check_tautological) {
+                if (/assert\.True\s*\(\s*\w+\s*,\s*true\s*\)/.test(line) ||
+                    /assert\.Equal\s*\(\s*\w+\s*,\s*(\d+|"[^"]*")\s*,\s*\1\s*\)/.test(line)) {
+                    issues.push({
+                        file, line: i + 1, pattern: 'tautological-assertion',
+                        reason: 'Tautological assertion — comparing a constant to itself proves nothing',
+                    });
+                }
+            }
+            // End of function
+            if (braceDepth === 0 && testContent.trim()) {
+                const meaningful = testContent.split('\n').filter(l => {
+                    const t = l.trim();
+                    return t && t !== '{' && t !== '}' && !t.startsWith('//');
+                });
+                if (config.check_empty_tests && meaningful.length === 0) {
+                    issues.push({
+                        file, line: testStartLine, pattern: 'empty-test',
+                        reason: 'Empty test function — no test logic',
+                    });
+                }
+                else if (config.check_empty_tests && !hasAssertion && meaningful.length > 0) {
+                    issues.push({
+                        file, line: testStartLine, pattern: 'no-assertion',
+                        reason: 'Test has no assertions (t.Error, t.Fatal, assert.*) — executes code but never verifies',
+                    });
+                }
+                inTestFunc = false;
+            }
+        }
+    }
+}
+/**
+ * Java/Kotlin test quality checks.
+ * JUnit 4: @Test + Assert.assertEquals, assertTrue, etc.
+ * JUnit 5: @Test + Assertions.assertEquals, assertThrows, etc.
+ * Kotlin: @Test + kotlin.test assertEquals, etc.
+ */
+export function checkJavaKotlinTestQuality(content, file, ext, issues, config) {
+    const lines = content.split('\n');
+    const isKotlin = ext === '.kt';
+    let inTestMethod = false;
+    let testStartLine = 0;
+    let braceDepth = 0;
+    let hasAssertion = false;
+    let mockCount = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Detect @Test annotation (next non-empty line is the method)
+        if (trimmed === '@Test' || /^@Test\s*(\(|$)/.test(trimmed)) {
+            // Look for the method signature on this or next lines
+            for (let j = i + 1; j < Math.min(i + 3, lines.length); j++) {
+                const methodLine = lines[j].trim();
+                const methodMatch = isKotlin
+                    ? methodLine.match(/^(?:fun|suspend\s+fun)\s+(\w+)\s*\(/)
+                    : methodLine.match(/^(?:public\s+|private\s+|protected\s+)?(?:static\s+)?void\s+(\w+)\s*\(/);
+                if (methodMatch) {
+                    inTestMethod = true;
+                    testStartLine = j + 1;
+                    braceDepth = 0;
+                    hasAssertion = false;
+                    mockCount = 0;
+                    // Count braces
+                    for (const ch of lines[j]) {
+                        if (ch === '{')
+                            braceDepth++;
+                        if (ch === '}')
+                            braceDepth--;
+                    }
+                    i = j;
+                    break;
+                }
+            }
+            continue;
+        }
+        if (inTestMethod) {
+            for (const ch of line) {
+                if (ch === '{')
+                    braceDepth++;
+                if (ch === '}')
+                    braceDepth--;
+            }
+            // JUnit 4/5 assertions
+            if (/\b(?:assert(?:Equals|True|False|NotNull|Null|That|Throws|DoesNotThrow|Same|NotSame|ArrayEquals)|assertEquals|assertTrue|assertFalse|assertNotNull|assertNull|assertThrows)\s*\(/.test(line)) {
+                hasAssertion = true;
+            }
+            // Kotlin test assertions
+            if (isKotlin && /\b(?:assertEquals|assertTrue|assertFalse|assertNotNull|assertNull|assertFailsWith|assertIs|assertContains|expect)\s*[({]/.test(line)) {
+                hasAssertion = true;
+            }
+            // Hamcrest / AssertJ
+            if (/\bassertThat\s*\(/.test(line) || /\.should\w*\(/.test(line)) {
+                hasAssertion = true;
+            }
+            // Verify (Mockito)
+            if (/\bverify\s*\(/.test(line)) {
+                hasAssertion = true;
+            }
+            // Mock counting
+            if (/\b(?:mock|spy|when|doReturn|doThrow|doNothing|Mockito\.\w+)\s*\(/.test(line) ||
+                /@Mock\b/.test(line) || /@InjectMocks\b/.test(line)) {
+                mockCount++;
+            }
+            // Tautological
+            if (config.check_tautological) {
+                if (/assertEquals\s*\(\s*true\s*,\s*true\s*\)/.test(line) ||
+                    /assertTrue\s*\(\s*true\s*\)/.test(line) ||
+                    /assertEquals\s*\(\s*(\d+)\s*,\s*\1\s*\)/.test(line)) {
+                    issues.push({
+                        file, line: i + 1, pattern: 'tautological-assertion',
+                        reason: 'Tautological assertion — comparing a constant to itself proves nothing',
+                    });
+                }
+            }
+            // End of method
+            if (braceDepth === 0) {
+                if (config.check_empty_tests && !hasAssertion) {
+                    issues.push({
+                        file, line: testStartLine, pattern: 'no-assertion',
+                        reason: 'Test has no assertions — executes code but never verifies results',
+                    });
+                }
+                if (config.check_mock_heavy && mockCount > config.max_mocks_per_test) {
+                    issues.push({
+                        file, line: testStartLine, pattern: 'mock-heavy',
+                        reason: `Test uses ${mockCount} mocks (max: ${config.max_mocks_per_test}) — may be testing mocks, not real behavior`,
+                    });
+                }
+                inTestMethod = false;
+            }
+        }
+    }
+}

package/dist/gates/test-quality.d.ts

@@ -50,18 +50,4 @@ export declare class TestQualityGate extends Gate {
     private analyzeJSTestBlock;
     private checkPythonTestQuality;
     private analyzePythonTestBlock;
-    /**
-     * Go test quality checks.
-     * Go tests use func TestXxx(t *testing.T) pattern.
-     * Assertions via t.Fatal, t.Error, t.Fatalf, t.Errorf, t.Fail, t.FailNow.
-     * Also checks for t.Run subtests and table-driven patterns.
-     */
-    private checkGoTestQuality;
-    /**
-     * Java/Kotlin test quality checks.
-     * JUnit 4: @Test + Assert.assertEquals, assertTrue, etc.
-     * JUnit 5: @Test + Assertions.assertEquals, assertThrows, etc.
-     * Kotlin: @Test + kotlin.test assertEquals, etc.
-     */
-    private checkJavaKotlinTestQuality;
 }

package/dist/gates/test-quality.js

@@ -26,6 +26,7 @@
 import { Gate } from './base.js';
 import { FileScanner } from '../utils/scanner.js';
 import { Logger } from '../utils/logger.js';
+import { checkGoTestQuality, checkJavaKotlinTestQuality } from './test-quality-lang.js';
 import fs from 'fs-extra';
 import path from 'path';
 export class TestQualityGate extends Gate {
@@ -76,10 +77,20 @@ export class TestQualityGate extends Gate {
                     this.checkPythonTestQuality(content, file, issues);
                 }
                 else if (ext === '.go') {
-                    this.checkGoTestQuality(content, file, issues);
+                    checkGoTestQuality(content, file, issues, {
+                        check_empty_tests: this.config.check_empty_tests,
+                        check_tautological: this.config.check_tautological,
+                        check_mock_heavy: this.config.check_mock_heavy,
+                        max_mocks_per_test: this.config.max_mocks_per_test,
+                    });
                 }
                 else if (ext === '.java' || ext === '.kt') {
-                    this.checkJavaKotlinTestQuality(content, file, ext, issues);
+                    checkJavaKotlinTestQuality(content, file, ext, issues, {
+                        check_empty_tests: this.config.check_empty_tests,
+                        check_tautological: this.config.check_tautological,
+                        check_mock_heavy: this.config.check_mock_heavy,
+                        max_mocks_per_test: this.config.max_mocks_per_test,
+                    });
                 }
             }
             catch { /* skip */ }
@@ -325,188 +336,4 @@ export class TestQualityGate extends Gate {
             });
         }
     }
-    /**
-     * Go test quality checks.
-     * Go tests use func TestXxx(t *testing.T) pattern.
-     * Assertions via t.Fatal, t.Error, t.Fatalf, t.Errorf, t.Fail, t.FailNow.
-     * Also checks for t.Run subtests and table-driven patterns.
-     */
-    checkGoTestQuality(content, file, issues) {
-        const lines = content.split('\n');
-        let inTestFunc = false;
-        let testStartLine = 0;
-        let braceDepth = 0;
-        let hasAssertion = false;
-        let testContent = '';
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const trimmed = line.trim();
-            // Detect test function: func TestXxx(t *testing.T) {
-            const testMatch = trimmed.match(/^func\s+(Test\w+|Benchmark\w+)\s*\(/);
-            if (testMatch && !inTestFunc) {
-                inTestFunc = true;
-                testStartLine = i + 1;
-                braceDepth = 0;
-                hasAssertion = false;
-                testContent = '';
-                // Count braces on this line
-                for (const ch of line) {
-                    if (ch === '{')
-                        braceDepth++;
-                    if (ch === '}')
-                        braceDepth--;
-                }
-                continue;
-            }
-            if (inTestFunc) {
-                testContent += line + '\n';
-                for (const ch of line) {
-                    if (ch === '{')
-                        braceDepth++;
-                    if (ch === '}')
-                        braceDepth--;
-                }
-                // Go test assertions: t.Fatal, t.Error, t.Fatalf, t.Errorf, t.Fail, t.FailNow
-                // Also: assert/require from testify, t.Run for subtests
-                if (/\bt\.\s*(?:Fatal|Error|Fatalf|Errorf|Fail|FailNow|Log|Logf|Skip|Skipf|Helper)\s*\(/.test(line) ||
-                    /\bt\.Run\s*\(/.test(line) ||
-                    /\bassert\.\w+\s*\(/.test(line) || /\brequire\.\w+\s*\(/.test(line) ||
-                    /\bif\b.*\bt\./.test(line)) {
-                    hasAssertion = true;
-                }
-                // Tautological: if true { t.Fatal... } or assert.True(t, true)
-                if (this.config.check_tautological) {
-                    if (/assert\.True\s*\(\s*\w+\s*,\s*true\s*\)/.test(line) ||
-                        /assert\.Equal\s*\(\s*\w+\s*,\s*(\d+|"[^"]*")\s*,\s*\1\s*\)/.test(line)) {
-                        issues.push({
-                            file, line: i + 1, pattern: 'tautological-assertion',
-                            reason: 'Tautological assertion — comparing a constant to itself proves nothing',
-                        });
-                    }
-                }
-                // End of function
-                if (braceDepth === 0 && testContent.trim()) {
-                    const meaningful = testContent.split('\n').filter(l => {
-                        const t = l.trim();
-                        return t && t !== '{' && t !== '}' && !t.startsWith('//');
-                    });
-                    if (this.config.check_empty_tests && meaningful.length === 0) {
-                        issues.push({
-                            file, line: testStartLine, pattern: 'empty-test',
-                            reason: 'Empty test function — no test logic',
-                        });
-                    }
-                    else if (this.config.check_empty_tests && !hasAssertion && meaningful.length > 0) {
-                        issues.push({
-                            file, line: testStartLine, pattern: 'no-assertion',
-                            reason: 'Test has no assertions (t.Error, t.Fatal, assert.*) — executes code but never verifies',
-                        });
-                    }
-                    inTestFunc = false;
-                }
-            }
-        }
-    }
-    /**
-     * Java/Kotlin test quality checks.
-     * JUnit 4: @Test + Assert.assertEquals, assertTrue, etc.
-     * JUnit 5: @Test + Assertions.assertEquals, assertThrows, etc.
-     * Kotlin: @Test + kotlin.test assertEquals, etc.
-     */
-    checkJavaKotlinTestQuality(content, file, ext, issues) {
-        const lines = content.split('\n');
-        const isKotlin = ext === '.kt';
-        let inTestMethod = false;
-        let testStartLine = 0;
-        let braceDepth = 0;
-        let hasAssertion = false;
-        let mockCount = 0;
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const trimmed = line.trim();
-            // Detect @Test annotation (next non-empty line is the method)
-            if (trimmed === '@Test' || /^@Test\s*(\(|$)/.test(trimmed)) {
-                // Look for the method signature on this or next lines
-                for (let j = i + 1; j < Math.min(i + 3, lines.length); j++) {
-                    const methodLine = lines[j].trim();
-                    const methodMatch = isKotlin
-                        ? methodLine.match(/^(?:fun|suspend\s+fun)\s+(\w+)\s*\(/)
-                        : methodLine.match(/^(?:public\s+|private\s+|protected\s+)?(?:static\s+)?void\s+(\w+)\s*\(/);
-                    if (methodMatch) {
-                        inTestMethod = true;
-                        testStartLine = j + 1;
-                        braceDepth = 0;
-                        hasAssertion = false;
-                        mockCount = 0;
-                        // Count braces
-                        for (const ch of lines[j]) {
-                            if (ch === '{')
-                                braceDepth++;
-                            if (ch === '}')
-                                braceDepth--;
-                        }
-                        i = j;
-                        break;
-                    }
-                }
-                continue;
-            }
-            if (inTestMethod) {
-                for (const ch of line) {
-                    if (ch === '{')
-                        braceDepth++;
-                    if (ch === '}')
-                        braceDepth--;
-                }
-                // JUnit 4/5 assertions
-                if (/\b(?:assert(?:Equals|True|False|NotNull|Null|That|Throws|DoesNotThrow|Same|NotSame|ArrayEquals)|assertEquals|assertTrue|assertFalse|assertNotNull|assertNull|assertThrows)\s*\(/.test(line)) {
-                    hasAssertion = true;
-                }
-                // Kotlin test assertions
-                if (isKotlin && /\b(?:assertEquals|assertTrue|assertFalse|assertNotNull|assertNull|assertFailsWith|assertIs|assertContains|expect)\s*[({]/.test(line)) {
-                    hasAssertion = true;
-                }
-                // Hamcrest / AssertJ
-                if (/\bassertThat\s*\(/.test(line) || /\.should\w*\(/.test(line)) {
-                    hasAssertion = true;
-                }
-                // Verify (Mockito)
-                if (/\bverify\s*\(/.test(line)) {
-                    hasAssertion = true;
-                }
-                // Mock counting
-                if (/\b(?:mock|spy|when|doReturn|doThrow|doNothing|Mockito\.\w+)\s*\(/.test(line) ||
-                    /@Mock\b/.test(line) || /@InjectMocks\b/.test(line)) {
-                    mockCount++;
-                }
-                // Tautological
-                if (this.config.check_tautological) {
-                    if (/assertEquals\s*\(\s*true\s*,\s*true\s*\)/.test(line) ||
-                        /assertTrue\s*\(\s*true\s*\)/.test(line) ||
-                        /assertEquals\s*\(\s*(\d+)\s*,\s*\1\s*\)/.test(line)) {
-                        issues.push({
-                            file, line: i + 1, pattern: 'tautological-assertion',
-                            reason: 'Tautological assertion — comparing a constant to itself proves nothing',
-                        });
-                    }
-                }
-                // End of method
-                if (braceDepth === 0) {
-                    if (this.config.check_empty_tests && !hasAssertion) {
-                        issues.push({
-                            file, line: testStartLine, pattern: 'no-assertion',
-                            reason: 'Test has no assertions — executes code but never verifies results',
-                        });
-                    }
-                    if (this.config.check_mock_heavy && mockCount > this.config.max_mocks_per_test) {
-                        issues.push({
-                            file, line: testStartLine, pattern: 'mock-heavy',
-                            reason: `Test uses ${mockCount} mocks (max: ${this.config.max_mocks_per_test}) — may be testing mocks, not real behavior`,
-                        });
-                    }
-                    inTestMethod = false;
-                }
-            }
-        }
-    }
 }

package/dist/index.d.ts

@@ -9,3 +9,13 @@ export { RetryLoopBreakerGate } from './gates/retry-loop-breaker.js';
 export * from './utils/logger.js';
 export * from './services/score-history.js';
 export * from './hooks/index.js';
+export { loadSettings, saveSettings, getSettingsPath, resolveDeepOptions, getProviderKey, getAgentConfig, getCliPreferences, updateProviderKey, removeProviderKey } from './settings.js';
+export type { RigourSettings, ResolvedDeepOptions, CLIDeepOptions } from './settings.js';
+export { DeepAnalysisGate } from './gates/deep-analysis.js';
+export { createProvider } from './inference/index.js';
+export type { InferenceProvider, DeepFinding, DeepAnalysisResult, ModelTier } from './inference/types.js';
+export { MODELS } from './inference/types.js';
+export { isModelCached, getModelsDir, getModelInfo } from './inference/model-manager.js';
+export { extractFacts, factsToPromptString } from './deep/fact-extractor.js';
+export { openDatabase, isSQLiteAvailable, insertScan, insertFindings, getRecentScans, getScoreTrendFromDB, getTopIssues, reinforcePattern, getStrongPatterns } from './storage/index.js';
+export type { RigourDB } from './storage/index.js';

package/dist/index.js

@@ -9,7 +9,17 @@ export { RetryLoopBreakerGate } from './gates/retry-loop-breaker.js';
 export * from './utils/logger.js';
 export * from './services/score-history.js';
 export * from './hooks/index.js';
+// Settings Module (Global user config at ~/.rigour/settings.json)
+export { loadSettings, saveSettings, getSettingsPath, resolveDeepOptions, getProviderKey, getAgentConfig, getCliPreferences, updateProviderKey, removeProviderKey } from './settings.js';
+// Deep Analysis Pipeline (v4.0+)
+export { DeepAnalysisGate } from './gates/deep-analysis.js';
+export { createProvider } from './inference/index.js';
+export { MODELS } from './inference/types.js';
+export { isModelCached, getModelsDir, getModelInfo } from './inference/model-manager.js';
+export { extractFacts, factsToPromptString } from './deep/fact-extractor.js';
+// Storage (SQLite Brain)
+export { openDatabase, isSQLiteAvailable, insertScan, insertFindings, getRecentScans, getScoreTrendFromDB, getTopIssues, reinforcePattern, getStrongPatterns } from './storage/index.js';
 // Pattern Index is intentionally NOT exported here to prevent
-// native dependency issues (sharp/transformers) from leaking into 
-// non-AI parts of the system. 
+// native dependency issues (sharp/transformers) from leaking into
+// non-AI parts of the system.
 // Import from @rigour-labs/core/pattern-index instead.

package/dist/inference/cloud-provider.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Cloud API Provider — runs inference via ANY cloud LLM API.
+ *
+ * The moat is local-first. But if a user brings their own key,
+ * we don't block them. No limitations. Support EVERY provider:
+ *
+ * - 'claude'/'anthropic' → Anthropic SDK (native)
+ * - Everything else → OpenAI-compatible SDK (works with OpenAI, Gemini, Groq,
+ *   Mistral, Together, Fireworks, Perplexity, DeepSeek, self-hosted vLLM,
+ *   Ollama, LM Studio, any OpenAI-compatible endpoint)
+ *
+ * User provides: api_key + provider name + optional base_url + optional model_name
+ * We figure out the rest. Their key, their choice.
+ */
+import type { InferenceProvider, InferenceOptions } from './types.js';
+export declare class CloudProvider implements InferenceProvider {
+    readonly name: string;
+    private client;
+    private providerName;
+    private apiKey;
+    private baseUrl?;
+    private modelName;
+    private isClaude;
+    constructor(providerName: string, apiKey: string, options?: {
+        baseUrl?: string;
+        modelName?: string;
+    });
+    isAvailable(): Promise<boolean>;
+    setup(onProgress?: (message: string) => void): Promise<void>;
+    analyze(prompt: string, options?: InferenceOptions): Promise<string>;
+    private analyzeClaude;
+    private analyzeOpenAICompat;
+    dispose(): void;
+}

package/dist/inference/cloud-provider.js

@@ -0,0 +1,126 @@
+/** Default models per provider (user can override via model_name) */
+const DEFAULT_MODELS = {
+    claude: 'claude-opus-4-6',
+    anthropic: 'claude-sonnet-4-6',
+    openai: 'gpt-4o-mini',
+    gemini: 'gemini-3-flash',
+    groq: 'llama-3.1-70b-versatile',
+    mistral: 'mistral-large-latest',
+    together: 'meta-llama/Llama-3.1-70B-Instruct-Turbo',
+    fireworks: 'accounts/fireworks/models/llama-v3p1-70b-instruct',
+    deepseek: 'deepseek-coder',
+    perplexity: 'llama-3.1-sonar-large-128k-online',
+    ollama: 'qwen2.5-coder:7b',
+    lmstudio: 'qwen2.5-coder-7b-instruct',
+};
+/** Default base URLs per provider */
+const DEFAULT_BASE_URLS = {
+    openai: 'https://api.openai.com/v1',
+    gemini: 'https://generativelanguage.googleapis.com/v1beta/openai',
+    groq: 'https://api.groq.com/openai/v1',
+    mistral: 'https://api.mistral.ai/v1',
+    together: 'https://api.together.xyz/v1',
+    fireworks: 'https://api.fireworks.ai/inference/v1',
+    deepseek: 'https://api.deepseek.com/v1',
+    perplexity: 'https://api.perplexity.ai',
+    ollama: 'http://localhost:11434/v1',
+    lmstudio: 'http://localhost:1234/v1',
+};
+export class CloudProvider {
+    name;
+    client = null;
+    providerName;
+    apiKey;
+    baseUrl;
+    modelName;
+    isClaude;
+    constructor(providerName, apiKey, options) {
+        if (!apiKey || apiKey.trim().length === 0) {
+            throw new Error(`API key cannot be empty for provider "${providerName}"`);
+        }
+        this.providerName = providerName.toLowerCase();
+        this.apiKey = apiKey.trim();
+        this.baseUrl = options?.baseUrl;
+        this.modelName = options?.modelName || DEFAULT_MODELS[this.providerName] || 'gpt-4o-mini';
+        this.isClaude = this.providerName === 'claude' || this.providerName === 'anthropic';
+        this.name = `cloud-${this.providerName}`;
+    }
+    async isAvailable() {
+        return !!this.apiKey;
+    }
+    async setup(onProgress) {
+        if (this.isClaude) {
+            try {
+                const { default: Anthropic } = await import('@anthropic-ai/sdk');
+                this.client = new Anthropic({ apiKey: this.apiKey });
+                onProgress?.(`✓ ${this.providerName} API connected (model: ${this.modelName})`);
+            }
+            catch {
+                throw new Error('Claude API SDK not installed. Run: npm install @anthropic-ai/sdk');
+            }
+        }
+        else {
+            // OpenAI-compatible SDK — works with literally everything.
+            // OpenAI, Groq, Mistral, Together, Fireworks, DeepSeek, Perplexity,
+            // Gemini, Ollama, LM Studio, vLLM, any OpenAI-compatible endpoint.
+            // No limitations. User's key, user's choice.
+            try {
+                const { default: OpenAI } = await import('openai');
+                const baseURL = this.baseUrl || DEFAULT_BASE_URLS[this.providerName] || undefined;
+                this.client = new OpenAI({
+                    apiKey: this.apiKey,
+                    ...(baseURL ? { baseURL } : {}),
+                });
+                onProgress?.(`✓ ${this.providerName} API connected (model: ${this.modelName})`);
+            }
+            catch {
+                throw new Error('OpenAI SDK not installed (used for all OpenAI-compatible APIs). Run: npm install openai');
+            }
+        }
+    }
+    async analyze(prompt, options) {
+        if (!this.client) {
+            throw new Error('Provider not set up. Call setup() first.');
+        }
+        if (this.isClaude) {
+            return this.analyzeClaude(prompt, options);
+        }
+        else {
+            return this.analyzeOpenAICompat(prompt, options);
+        }
+    }
+    async analyzeClaude(prompt, options) {
+        const response = await this.client.messages.create({
+            model: this.modelName,
+            max_tokens: options?.maxTokens || 2048,
+            temperature: options?.temperature || 0.1,
+            messages: [
+                { role: 'user', content: prompt }
+            ],
+        });
+        const textBlock = response.content.find((b) => b.type === 'text');
+        if (!textBlock?.text) {
+            throw new Error(`Empty response from ${this.providerName} API (model: ${this.modelName}). Response had ${response.content.length} blocks but no text.`);
+        }
+        return textBlock.text;
+    }
+    async analyzeOpenAICompat(prompt, options) {
+        const response = await this.client.chat.completions.create({
+            model: this.modelName,
+            max_tokens: options?.maxTokens || 2048,
+            temperature: options?.temperature || 0.1,
+            messages: [
+                { role: 'user', content: prompt }
+            ],
+            ...(options?.jsonMode ? { response_format: { type: 'json_object' } } : {}),
+        });
+        const content = response.choices[0]?.message?.content;
+        if (!content) {
+            throw new Error(`Empty response from ${this.providerName} API (model: ${this.modelName}). No content in choices.`);
+        }
+        return content;
+    }
+    dispose() {
+        this.client = null;
+    }
+}

package/dist/inference/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Inference provider factory and exports.
+ */
+export type { InferenceProvider, InferenceOptions, DeepFinding, DeepAnalysisResult, ModelTier, ModelInfo } from './types.js';
+export { MODELS } from './types.js';
+export { SidecarProvider } from './sidecar-provider.js';
+export { CloudProvider } from './cloud-provider.js';
+export { ensureModel, isModelCached, getModelPath, getModelInfo, downloadModel, getModelsDir } from './model-manager.js';
+import type { InferenceProvider } from './types.js';
+import type { DeepOptions } from '../types/index.js';
+/**
+ * Create the appropriate inference provider based on options.
+ *
+ * - No API key → SidecarProvider (local llama.cpp binary)
+ * - API key + any provider → CloudProvider (no restrictions, user's key, user's choice)
+ */
+export declare function createProvider(options: DeepOptions): InferenceProvider;