@alint-js/core 0.0.8 → 0.0.9

package/dist/agent.d.mts

@@ -1,32 +1,7 @@
-import { r as ResolvedModel } from "./types-BPiUTLXT.mjs";
+import { B as AgentTool, L as AgentAdapter, R as AgentRequest, V as AgentUsage, g as RuleContext, z as AgentResult } from "./types-DQfoxG8J.mjs";
 
-//#region src/agent/types.d.ts
-type AgentAdapter = (request: AgentRequest) => Promise<AgentResult>;
-interface AgentRequest {
-  instructions: string;
-  model: ResolvedModel;
-  prompt: string;
-  signal?: AbortSignal;
-  tools: AgentTool[];
-}
-interface AgentResult {
-  answer: string;
-  usage?: AgentUsage;
-}
-/** Agent-agnostic tool definition. Each adapter translates it to its framework's tool format. */
-interface AgentTool {
-  description: string;
-  execute: (input: unknown) => Promise<unknown> | unknown;
-  name: string;
-  parameters: Record<string, unknown>;
-}
-interface AgentUsage {
-  inputTokens?: number;
-  outputTokens?: number;
-  totalTokens?: number;
-}
-//#endregion
 //#region src/agent/index.d.ts
 declare function defineTool(tool: AgentTool): AgentTool;
+declare function requireAgent(context: Pick<RuleContext, 'agent' | 'id'>): AgentAdapter;
 //#endregion
-export { type AgentAdapter, type AgentRequest, type AgentResult, type AgentTool, type AgentUsage, defineTool };
+export { type AgentAdapter, type AgentRequest, type AgentResult, type AgentTool, type AgentUsage, defineTool, requireAgent };

package/dist/agent.mjs

@@ -2,5 +2,9 @@
 function defineTool(tool) {
 	return tool;
 }
+function requireAgent(context) {
+	if (!context.agent) throw new TypeError(`Rule "${context.id}" requires an agent, but none is configured. Set "agent" in alint config (e.g. agent: createApeiraAdapter()).`);
+	return context.agent;
+}
 //#endregion
-export { defineTool };
+export { defineTool, requireAgent };

package/dist/index.d.mts

@@ -1,195 +1,8 @@
-import { a as ModelSize, c as RunnerConfig, i as ResolvedProvider, l as SetupConfig, n as ResolveModelOptions, o as ProviderDefinition, r as ResolvedModel, s as ProviderType, t as ModelRequirement, u as SetupModelDefinition } from "./types-BPiUTLXT.mjs";
+import { A as SourcePosition, C as LineRange, D as ProcessorPostprocessContext, E as ProcessorContext, F as SourceTargetOrigin, G as ResolvedProvider, H as ModelRequirement, I as SourceText, J as ProviderType, K as ModelSize, M as SourceRuntime, N as SourceTarget, O as SourceFile, P as SourceTargetKind, Q as SetupModelDefinition, S as LanguageContext, T as ProcessedSourceOrigin, U as ResolveModelOptions, W as ResolvedModel, X as RunnerStatsConfig, Y as RunnerConfig, Z as SetupConfig, _ as RuleDefinition, a as AlintLinterOptions, b as RuleRegistry, c as DiagnosticLocation, d as LanguageDefinition, f as PluginDefinition, g as RuleContext, h as RuleConfigEntry, i as AlintConfigItem, j as SourceRange, k as SourceLocation, l as EnabledRule, m as RuleCacheConfig, n as AlintConfigExtends, o as Awaitable, p as ProcessorDefinition, q as ProviderDefinition, r as AlintConfigInput, s as DiagnosticDescriptor, t as AlintConfig, u as IgnoreConfig, v as RuleHandlers, w as ProcessedSource, x as RuleSeverity, y as RuleInferenceUsageRecord } from "./types-DQfoxG8J.mjs";
 
-//#region src/core/source/types.d.ts
-interface LanguageContext {
-  cwd: string;
-  languageOptions: Record<string, unknown>;
-  src: SourceRuntime;
-}
-interface LineRange {
-  endLine: number;
-  startLine: number;
-}
-interface ProcessedSource {
-  identity: string;
-  language?: string;
-  origin?: ProcessedSourceOrigin;
-  path: string;
-  text: string;
-}
-interface ProcessedSourceOrigin {
-  physicalPath: string;
-  range?: SourceRange;
-  virtualPath?: string;
-}
-interface ProcessorContext {
-  cwd: string;
-  options: Record<string, unknown>;
-  src: SourceRuntime;
-}
-interface ProcessorPostprocessContext extends ProcessorContext {
-  file: SourceFile;
-  processedSources: ProcessedSource[];
-}
-interface SourceFile {
-  language: string;
-  lines: string[];
-  path: string;
-  text: string;
-}
-interface SourceLocation {
-  end: SourcePosition;
-  start: SourcePosition;
-}
-interface SourcePosition {
-  column: number;
-  line: number;
-}
-interface SourceRange {
-  end: number;
-  start: number;
-}
-interface SourceRuntime {
-  getText: (target: SourceFile | SourceTarget) => string;
-  readFile: (filePath: string) => Promise<SourceFile>;
-  sliceLines: (file: SourceFile, range: LineRange) => SourceText;
-  sliceRange: (file: SourceFile, range: SourceRange) => SourceText;
-}
-interface SourceTarget {
-  file: SourceFile;
-  identity: string;
-  kind: SourceTargetKind;
-  language: string;
-  loc?: SourceLocation;
-  metadata?: Record<string, unknown>;
-  name?: string;
-  origin?: SourceTargetOrigin;
-  range?: SourceRange;
-  text: string;
-}
-type SourceTargetKind = 'class' | 'file' | 'fragment' | 'function' | 'symbol' | (string & {});
-interface SourceTargetOrigin {
-  physicalPath: string;
-  range?: SourceRange;
-  virtualPath?: string;
-}
-interface SourceText {
-  filePath: string;
-  loc: SourceLocation;
-  text: string;
-}
-//#endregion
-//#region src/dsl/types.d.ts
-type AlintConfig = readonly AlintConfigInput[];
-type AlintConfigExtends = AlintConfigInput | string;
-type AlintConfigInput = AlintConfigItem | readonly AlintConfigInput[];
-interface AlintConfigItem {
-  basePath?: string;
-  extends?: readonly AlintConfigExtends[];
-  files?: readonly (readonly string[] | string)[];
-  ignore?: IgnoreConfig;
-  ignores?: readonly string[];
-  language?: string;
-  languageOptions?: Record<string, unknown>;
-  linterOptions?: AlintLinterOptions;
-  name?: string;
-  plugins?: Record<string, PluginDefinition>;
-  processor?: ProcessorDefinition | string;
-  rules?: Record<string, RuleConfigEntry>;
-  runner?: RunnerConfig;
-  settings?: Record<string, unknown>;
-}
-interface AlintLinterOptions {
-  noInlineConfig?: boolean;
-  reportUnusedDisableDirectives?: RuleSeverity;
-}
-type Awaitable<T> = Promise<T> | T;
-interface DiagnosticDescriptor {
-  evidence?: unknown;
-  filePath?: string;
-  loc?: DiagnosticLocation;
-  message: string;
-}
-interface DiagnosticLocation {
-  end?: {
-    column: number;
-    line: number;
-  };
-  start: {
-    column: number;
-    line: number;
-  };
-}
-interface EnabledRule {
-  id: string;
-  localId: string;
-  rule: RuleDefinition;
-  severity: Exclude<RuleSeverity, 'off'>;
-}
-interface IgnoreConfig {
-  gitignore?: boolean;
-}
-interface LanguageDefinition {
-  extensions?: readonly string[];
-  extract: (file: SourceFile, context: LanguageContext) => Awaitable<SourceTarget[]>;
-  name: string;
-}
-interface PluginDefinition {
-  configs?: Record<string, AlintConfigInput>;
-  languages?: Record<string, LanguageDefinition>;
-  processors?: Record<string, ProcessorDefinition>;
-  rules?: Record<string, RuleDefinition>;
-}
-interface ProcessorDefinition {
-  postprocess?: (diagnostics: DiagnosticDescriptor[], context: ProcessorPostprocessContext) => Awaitable<DiagnosticDescriptor[]>;
-  preprocess: (file: SourceFile, context: ProcessorContext) => Awaitable<ProcessedSource[]>;
-}
-type RuleCacheConfig = boolean | {
-  level?: 'target';
-};
-type RuleConfigEntry = [RuleSeverity] | RuleSeverity;
-interface RuleContext {
-  cwd: string;
-  id: string;
-  localId: string;
-  logger: {
-    debug: (...args: unknown[]) => void;
-  };
-  metering: {
-    recordUsage: (usage: RuleInferenceUsageRecord) => void;
-  };
-  model: (selector?: ModelRequirement | string) => Promise<ResolvedModel>;
-  outputLanguage?: string;
-  report: (diagnostic: DiagnosticDescriptor) => void;
-  settings: Record<string, unknown>;
-  src: SourceRuntime;
-}
-interface RuleDefinition {
-  cache?: RuleCacheConfig;
-  create: (context: RuleContext) => RuleHandlers;
-  model?: ModelRequirement;
-}
-interface RuleHandlers {
-  onTarget?: (target: SourceTarget) => Awaitable<void>;
-}
-interface RuleInferenceUsageRecord {
-  filePath?: string;
-  inputTokens?: number;
-  metadata?: unknown;
-  modelId: string;
-  outputTokens?: number;
-  providerId: string;
-  ruleId?: string;
-  totalTokens?: number;
-}
-interface RuleRegistry {
-  enabledRules: EnabledRule[];
-  rules: Map<string, RuleDefinition>;
-}
-type RuleSeverity = 'error' | 'off' | 'warn';
-//#endregion
 //#region src/config/config-array.d.ts
 interface EffectiveAlintConfig {
+  agent?: AlintConfigItem['agent'];
   language?: string;
   languageOptions: Record<string, unknown>;
   linterOptions: Record<string, unknown>;
@@ -395,4 +208,4 @@ declare function buildRuleRegistry(config: Pick<EffectiveAlintConfig, 'plugins'
 //#region src/models/resolve.d.ts
 declare function resolveModel(registry: SetupConfig, options?: ResolveModelOptions): ResolvedModel;
 //#endregion
-export { type AlintConfig, type AlintConfigExtends, type AlintConfigInput, type AlintConfigItem, type AlintLinterOptions, AlintRunError, type Awaitable, type Diagnostic, type DiagnosticDescriptor, type DiagnosticLocation, type DiagnosticProgressPayload, type EffectiveAlintConfig, type EnabledRule, type FileProgressPayload, type IgnoreConfig, type InferenceUsageRecord, type LanguageContext, type LanguageDefinition, type LanguageRegistry, type LineRange, type ModelRequirement, type ModelSize, type PluginDefinition, type ProcessedSource, type ProcessedSourceOrigin, type ProcessorContext, type ProcessorDefinition, type ProcessorPostprocessContext, type ProgressFilePath, type ProgressPath, type ProgressReporter, type ProgressTargetKind, type ProviderDefinition, type ProviderType, type ResolveConfigResult, type ResolveLanguageOptions, type ResolveModelOptions, type ResolvedModel, type ResolvedProvider, type RuleCacheConfig, type RuleConfigEntry, type RuleContext, type RuleDefinition, type RuleEndPayload, type RuleHandlers, type RuleInferenceUsageRecord, type RuleRegistry, type RuleSeverity, type RuleStartPayload, type RunEndPayload, type RunOptions, type RunResult, type RunStartPayload, type RunUsage, type RunnerConfig, type SetupConfig, type SetupModelDefinition, type SourceFile, type SourceLocation, type SourcePosition, type SourceRange, type SourceRuntime, type SourceTarget, type SourceTargetKind, type SourceTargetOrigin, type SourceText, type TargetProgressPayload, type UsageProgressPayload, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, extractJsSourceTargets, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, registerLanguage, resolveConfigForFile, resolveLanguage, resolveModel, runAlint, sliceLines, sliceRange };
+export { type AlintConfig, type AlintConfigExtends, type AlintConfigInput, type AlintConfigItem, type AlintLinterOptions, AlintRunError, type Awaitable, type Diagnostic, type DiagnosticDescriptor, type DiagnosticLocation, type DiagnosticProgressPayload, type EffectiveAlintConfig, type EnabledRule, type FileProgressPayload, type IgnoreConfig, type InferenceUsageRecord, type LanguageContext, type LanguageDefinition, type LanguageRegistry, type LineRange, type ModelRequirement, type ModelSize, type PluginDefinition, type ProcessedSource, type ProcessedSourceOrigin, type ProcessorContext, type ProcessorDefinition, type ProcessorPostprocessContext, type ProgressFilePath, type ProgressPath, type ProgressReporter, type ProgressTargetKind, type ProviderDefinition, type ProviderType, type ResolveConfigResult, type ResolveLanguageOptions, type ResolveModelOptions, type ResolvedModel, type ResolvedProvider, type RuleCacheConfig, type RuleConfigEntry, type RuleContext, type RuleDefinition, type RuleEndPayload, type RuleHandlers, type RuleInferenceUsageRecord, type RuleRegistry, type RuleSeverity, type RuleStartPayload, type RunEndPayload, type RunOptions, type RunResult, type RunStartPayload, type RunUsage, type RunnerConfig, type RunnerStatsConfig, type SetupConfig, type SetupModelDefinition, type SourceFile, type SourceLocation, type SourcePosition, type SourceRange, type SourceRuntime, type SourceTarget, type SourceTargetKind, type SourceTargetOrigin, type SourceText, type TargetProgressPayload, type UsageProgressPayload, buildRuleRegistry, createBuiltInLanguageRegistry, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, extractJsSourceTargets, hasDiscoveryFilePatterns, matchesDiscoveryFile, normalizeConfig, registerLanguage, resolveConfigForFile, resolveLanguage, resolveModel, runAlint, sliceLines, sliceRange };

package/dist/index.mjs

@@ -180,6 +180,7 @@ function mergeConfig(config, item) {
 	Object.assign(config.settings, item.settings);
 	Object.assign(config.languageOptions, item.languageOptions);
 	Object.assign(config.linterOptions, item.linterOptions);
+	if (item.agent !== void 0) config.agent = item.agent;
 	if (item.language !== void 0) config.language = item.language;
 	if (item.processor !== void 0) config.processor = item.processor;
 	if (item.runner !== void 0) config.runner = {
@@ -647,7 +648,7 @@ function createBuiltInLanguageRegistry() {
 }
 //#endregion
 //#region package.json
-var version = "0.0.8";
+var version = "0.0.9";
 //#endregion
 //#region src/dsl/registry.ts
 function buildRuleRegistry(config) {
@@ -979,6 +980,7 @@ async function runAlint(options = {}) {
 		const ruleRuntimes = createRuleRuntimes({
 			cwd: cwd$1,
 			diagnostics,
+			effectiveAgent: effectiveConfig.agent,
 			effectiveSettings: effectiveConfig.settings,
 			options,
 			registry,
@@ -1176,6 +1178,7 @@ function createRuleRuntimes(options) {
 	return options.registry.enabledRules.map((enabledRule) => {
 		const executionState = new AsyncLocalStorage();
 		const context = {
+			agent: options.effectiveAgent,
 			cwd: options.cwd,
 			id: enabledRule.id,
 			localId: enabledRule.localId,

package/dist/types-DQfoxG8J.d.mts

@@ -0,0 +1,287 @@
+//#region src/config/types.d.ts
+type ModelSize = 'large' | 'medium' | 'small';
+interface ProviderDefinition {
+  endpoint: string;
+  headers?: Record<string, string>;
+  id: string;
+  models: SetupModelDefinition[];
+  type: ProviderType;
+}
+type ProviderType = 'openai-compatible';
+interface RunnerCacheConfig {
+  enabled?: boolean;
+  location?: string;
+}
+interface RunnerConfig {
+  cache?: boolean | RunnerCacheConfig;
+  fileConcurrency?: number;
+  ruleConcurrency?: number;
+  stats?: boolean | RunnerStatsConfig;
+  timeoutMs?: number;
+}
+interface RunnerStatsConfig {
+  enabled?: boolean;
+  location?: string;
+  retentionMonths?: number;
+}
+interface SetupConfig {
+  providers: ProviderDefinition[];
+  runner?: RunnerConfig;
+  version: 1;
+}
+interface SetupModelDefinition {
+  aliases?: string[];
+  capabilities?: string[];
+  contextWindow?: number;
+  defaultParams?: Record<string, unknown>;
+  id: string;
+  name?: string;
+  size?: ModelSize;
+}
+//#endregion
+//#region src/models/types.d.ts
+interface ModelRequirement {
+  capabilities?: string[];
+  minContextWindow?: number;
+  params?: Record<string, unknown>;
+  size?: ModelSize;
+}
+interface ResolvedModel {
+  aliases: string[];
+  capabilities: string[];
+  contextWindow?: number;
+  id: string;
+  name: string;
+  params: Record<string, unknown>;
+  provider: ResolvedProvider;
+  size?: ModelSize;
+}
+interface ResolvedProvider {
+  endpoint: string;
+  headers: Record<string, string>;
+  id: string;
+  type: 'openai-compatible';
+}
+interface ResolveModelOptions {
+  request?: string;
+  requirement?: ModelRequirement;
+  ruleId?: string;
+}
+//#endregion
+//#region src/agent/types.d.ts
+type AgentAdapter = (request: AgentRequest) => Promise<AgentResult>;
+interface AgentRequest {
+  instructions: string;
+  model: ResolvedModel;
+  prompt: string;
+  signal?: AbortSignal;
+  tools: AgentTool[];
+}
+interface AgentResult {
+  answer: string;
+  usage?: AgentUsage;
+}
+/** Agent-agnostic tool definition. Each adapter translates it to its framework's tool format. */
+interface AgentTool {
+  description: string;
+  execute: (input: unknown) => Promise<unknown> | unknown;
+  name: string;
+  parameters: Record<string, unknown>;
+}
+interface AgentUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+}
+//#endregion
+//#region src/core/source/types.d.ts
+interface LanguageContext {
+  cwd: string;
+  languageOptions: Record<string, unknown>;
+  src: SourceRuntime;
+}
+interface LineRange {
+  endLine: number;
+  startLine: number;
+}
+interface ProcessedSource {
+  identity: string;
+  language?: string;
+  origin?: ProcessedSourceOrigin;
+  path: string;
+  text: string;
+}
+interface ProcessedSourceOrigin {
+  physicalPath: string;
+  range?: SourceRange;
+  virtualPath?: string;
+}
+interface ProcessorContext {
+  cwd: string;
+  options: Record<string, unknown>;
+  src: SourceRuntime;
+}
+interface ProcessorPostprocessContext extends ProcessorContext {
+  file: SourceFile;
+  processedSources: ProcessedSource[];
+}
+interface SourceFile {
+  language: string;
+  lines: string[];
+  path: string;
+  text: string;
+}
+interface SourceLocation {
+  end: SourcePosition;
+  start: SourcePosition;
+}
+interface SourcePosition {
+  column: number;
+  line: number;
+}
+interface SourceRange {
+  end: number;
+  start: number;
+}
+interface SourceRuntime {
+  getText: (target: SourceFile | SourceTarget) => string;
+  readFile: (filePath: string) => Promise<SourceFile>;
+  sliceLines: (file: SourceFile, range: LineRange) => SourceText;
+  sliceRange: (file: SourceFile, range: SourceRange) => SourceText;
+}
+interface SourceTarget {
+  file: SourceFile;
+  identity: string;
+  kind: SourceTargetKind;
+  language: string;
+  loc?: SourceLocation;
+  metadata?: Record<string, unknown>;
+  name?: string;
+  origin?: SourceTargetOrigin;
+  range?: SourceRange;
+  text: string;
+}
+type SourceTargetKind = 'class' | 'file' | 'fragment' | 'function' | 'symbol' | (string & {});
+interface SourceTargetOrigin {
+  physicalPath: string;
+  range?: SourceRange;
+  virtualPath?: string;
+}
+interface SourceText {
+  filePath: string;
+  loc: SourceLocation;
+  text: string;
+}
+//#endregion
+//#region src/dsl/types.d.ts
+type AlintConfig = readonly AlintConfigInput[];
+type AlintConfigExtends = AlintConfigInput | string;
+type AlintConfigInput = AlintConfigItem | readonly AlintConfigInput[];
+interface AlintConfigItem {
+  agent?: AgentAdapter;
+  basePath?: string;
+  extends?: readonly AlintConfigExtends[];
+  files?: readonly (readonly string[] | string)[];
+  ignore?: IgnoreConfig;
+  ignores?: readonly string[];
+  language?: string;
+  languageOptions?: Record<string, unknown>;
+  linterOptions?: AlintLinterOptions;
+  name?: string;
+  plugins?: Record<string, PluginDefinition>;
+  processor?: ProcessorDefinition | string;
+  rules?: Record<string, RuleConfigEntry>;
+  runner?: RunnerConfig;
+  settings?: Record<string, unknown>;
+}
+interface AlintLinterOptions {
+  noInlineConfig?: boolean;
+  reportUnusedDisableDirectives?: RuleSeverity;
+}
+type Awaitable<T> = Promise<T> | T;
+interface DiagnosticDescriptor {
+  evidence?: unknown;
+  filePath?: string;
+  loc?: DiagnosticLocation;
+  message: string;
+}
+interface DiagnosticLocation {
+  end?: {
+    column: number;
+    line: number;
+  };
+  start: {
+    column: number;
+    line: number;
+  };
+}
+interface EnabledRule {
+  id: string;
+  localId: string;
+  rule: RuleDefinition;
+  severity: Exclude<RuleSeverity, 'off'>;
+}
+interface IgnoreConfig {
+  gitignore?: boolean;
+}
+interface LanguageDefinition {
+  extensions?: readonly string[];
+  extract: (file: SourceFile, context: LanguageContext) => Awaitable<SourceTarget[]>;
+  name: string;
+}
+interface PluginDefinition {
+  configs?: Record<string, AlintConfigInput>;
+  languages?: Record<string, LanguageDefinition>;
+  processors?: Record<string, ProcessorDefinition>;
+  rules?: Record<string, RuleDefinition>;
+}
+interface ProcessorDefinition {
+  postprocess?: (diagnostics: DiagnosticDescriptor[], context: ProcessorPostprocessContext) => Awaitable<DiagnosticDescriptor[]>;
+  preprocess: (file: SourceFile, context: ProcessorContext) => Awaitable<ProcessedSource[]>;
+}
+type RuleCacheConfig = boolean | {
+  level?: 'target';
+};
+type RuleConfigEntry = [RuleSeverity] | RuleSeverity;
+interface RuleContext {
+  agent?: AgentAdapter;
+  cwd: string;
+  id: string;
+  localId: string;
+  logger: {
+    debug: (...args: unknown[]) => void;
+  };
+  metering: {
+    recordUsage: (usage: RuleInferenceUsageRecord) => void;
+  };
+  model: (selector?: ModelRequirement | string) => Promise<ResolvedModel>;
+  outputLanguage?: string;
+  report: (diagnostic: DiagnosticDescriptor) => void;
+  settings: Record<string, unknown>;
+  src: SourceRuntime;
+}
+interface RuleDefinition {
+  cache?: RuleCacheConfig;
+  create: (context: RuleContext) => RuleHandlers;
+  model?: ModelRequirement;
+}
+interface RuleHandlers {
+  onTarget?: (target: SourceTarget) => Awaitable<void>;
+}
+interface RuleInferenceUsageRecord {
+  filePath?: string;
+  inputTokens?: number;
+  metadata?: unknown;
+  modelId: string;
+  outputTokens?: number;
+  providerId: string;
+  ruleId?: string;
+  totalTokens?: number;
+}
+interface RuleRegistry {
+  enabledRules: EnabledRule[];
+  rules: Map<string, RuleDefinition>;
+}
+type RuleSeverity = 'error' | 'off' | 'warn';
+//#endregion
+export { SourcePosition as A, AgentTool as B, LineRange as C, ProcessorPostprocessContext as D, ProcessorContext as E, SourceTargetOrigin as F, ResolvedProvider as G, ModelRequirement as H, SourceText as I, ProviderType as J, ModelSize as K, AgentAdapter as L, SourceRuntime as M, SourceTarget as N, SourceFile as O, SourceTargetKind as P, SetupModelDefinition as Q, AgentRequest as R, LanguageContext as S, ProcessedSourceOrigin as T, ResolveModelOptions as U, AgentUsage as V, ResolvedModel as W, RunnerStatsConfig as X, RunnerConfig as Y, SetupConfig as Z, RuleDefinition as _, AlintLinterOptions as a, RuleRegistry as b, DiagnosticLocation as c, LanguageDefinition as d, PluginDefinition as f, RuleContext as g, RuleConfigEntry as h, AlintConfigItem as i, SourceRange as j, SourceLocation as k, EnabledRule as l, RuleCacheConfig as m, AlintConfigExtends as n, Awaitable as o, ProcessorDefinition as p, ProviderDefinition as q, AlintConfigInput as r, DiagnosticDescriptor as s, AlintConfig as t, IgnoreConfig as u, RuleHandlers as v, ProcessedSource as w, RuleSeverity as x, RuleInferenceUsageRecord as y, AgentResult as z };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alint-js/core",
   "type": "module",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",

package/dist/types-BPiUTLXT.d.mts

@@ -1,65 +0,0 @@
-//#region src/config/types.d.ts
-type ModelSize = 'large' | 'medium' | 'small';
-interface ProviderDefinition {
-  endpoint: string;
-  headers?: Record<string, string>;
-  id: string;
-  models: SetupModelDefinition[];
-  type: ProviderType;
-}
-type ProviderType = 'openai-compatible';
-interface RunnerCacheConfig {
-  enabled?: boolean;
-  location?: string;
-}
-interface RunnerConfig {
-  cache?: boolean | RunnerCacheConfig;
-  fileConcurrency?: number;
-  ruleConcurrency?: number;
-  timeoutMs?: number;
-}
-interface SetupConfig {
-  providers: ProviderDefinition[];
-  runner?: RunnerConfig;
-  version: 1;
-}
-interface SetupModelDefinition {
-  aliases?: string[];
-  capabilities?: string[];
-  contextWindow?: number;
-  defaultParams?: Record<string, unknown>;
-  id: string;
-  name?: string;
-  size?: ModelSize;
-}
-//#endregion
-//#region src/models/types.d.ts
-interface ModelRequirement {
-  capabilities?: string[];
-  minContextWindow?: number;
-  params?: Record<string, unknown>;
-  size?: ModelSize;
-}
-interface ResolvedModel {
-  aliases: string[];
-  capabilities: string[];
-  contextWindow?: number;
-  id: string;
-  name: string;
-  params: Record<string, unknown>;
-  provider: ResolvedProvider;
-  size?: ModelSize;
-}
-interface ResolvedProvider {
-  endpoint: string;
-  headers: Record<string, string>;
-  id: string;
-  type: 'openai-compatible';
-}
-interface ResolveModelOptions {
-  request?: string;
-  requirement?: ModelRequirement;
-  ruleId?: string;
-}
-//#endregion
-export { ModelSize as a, RunnerConfig as c, ResolvedProvider as i, SetupConfig as l, ResolveModelOptions as n, ProviderDefinition as o, ResolvedModel as r, ProviderType as s, ModelRequirement as t, SetupModelDefinition as u };