@alint-js/core 0.0.4

package/dist/index.d.mts

@@ -0,0 +1,365 @@
+//#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/core/source/types.d.ts
+interface ClassUnit extends SourceUnit {
+  exported: boolean;
+  kind: 'class';
+}
+interface FunctionUnit extends SourceUnit {
+  async: boolean;
+  exported: boolean;
+  kind: 'function';
+}
+interface LineRange {
+  endLine: number;
+  startLine: number;
+}
+interface SourceFile {
+  language: 'javascript' | 'typescript' | 'unknown';
+  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 | SourceUnit) => string;
+  readFile: (filePath: string) => Promise<SourceFile>;
+  sliceLines: (file: SourceFile, range: LineRange) => SourceText;
+  sliceRange: (file: SourceFile, range: SourceRange) => SourceText;
+}
+interface SourceText {
+  filePath: string;
+  loc: SourceLocation;
+  text: string;
+}
+interface SourceUnit {
+  file: SourceFile;
+  kind: 'class' | 'function';
+  loc: SourceLocation;
+  name?: string;
+  range: SourceRange;
+  text: string;
+}
+//#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/dsl/types.d.ts
+interface AlintConfig {
+  ignore?: IgnoreConfig;
+  plugins?: PluginDefinition[];
+  rules?: Record<string, RuleConfigEntry>;
+  runner?: RunnerConfig;
+}
+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;
+  scope: string;
+  severity: Exclude<RuleSeverity, 'off'>;
+}
+interface IgnoreConfig {
+  gitignore?: boolean;
+}
+interface PluginDefinition {
+  rules: Record<string, RuleDefinition>;
+  scope: string;
+}
+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>;
+  report: (diagnostic: DiagnosticDescriptor) => void;
+  scope: string;
+  src: SourceRuntime;
+}
+interface RuleDefinition {
+  cache?: RuleCacheConfig;
+  create: (context: RuleContext) => RuleHandlers;
+  model?: ModelRequirement;
+}
+interface RuleHandlers {
+  onClass?: (classNode: ClassUnit) => Awaitable<void>;
+  onFile?: (file: SourceFile) => Awaitable<void>;
+  onFunction?: (functionNode: FunctionUnit) => 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/core/types.d.ts
+interface Diagnostic {
+  evidence?: unknown;
+  filePath: string;
+  loc?: DiagnosticLocation;
+  message: string;
+  model?: {
+    providerId: string;
+    requested?: string;
+    resolvedId: string;
+  };
+  ruleId: string;
+  severity: 'error' | 'warn';
+}
+interface DiagnosticProgressPayload {
+  diagnostic: Diagnostic;
+  diagnostics: Diagnostic[];
+  path?: ProgressPath;
+}
+interface FileProgressPayload {
+  endedAt?: number;
+  file: ProgressFilePath;
+  startedAt?: number;
+}
+type InferenceUsageRecord = Omit<RuleInferenceUsageRecord, 'ruleId'> & {
+  ruleId: string;
+};
+interface ProgressFilePath {
+  index: number;
+  path: string;
+  planned?: number;
+  total: number;
+}
+interface ProgressPath {
+  file: ProgressFilePath;
+  rule: {
+    id: string;
+    index: number;
+    total: number;
+  };
+  target: {
+    index: number;
+    kind: ProgressTargetKind;
+    name?: string;
+    total: number;
+  };
+}
+interface ProgressReporter {
+  onDiagnostic?: (payload: DiagnosticProgressPayload) => void;
+  onFileEnd?: (payload: FileProgressPayload) => void;
+  onFileStart?: (payload: FileProgressPayload) => void;
+  onRuleEnd?: (payload: RuleEndPayload) => void;
+  onRuleStart?: (payload: RuleStartPayload) => void;
+  onRunEnd?: (payload: RunEndPayload) => void;
+  onRunStart?: (payload: RunStartPayload) => void;
+  onTargetEnd?: (payload: TargetProgressPayload) => void;
+  onTargetStart?: (payload: TargetProgressPayload) => void;
+  onUsage?: (payload: UsageProgressPayload) => void;
+}
+type ProgressTargetKind = 'class' | 'file' | 'function';
+interface RuleEndPayload {
+  cache: 'hit' | 'miss';
+  endedAt?: number;
+  path: ProgressPath;
+  startedAt?: number;
+  state: 'completed' | 'errored';
+}
+interface RuleStartPayload {
+  path: ProgressPath;
+  startedAt?: number;
+}
+interface RunEndPayload {
+  cached: number;
+  completed: number;
+  diagnostics: Diagnostic[];
+  endedAt?: number;
+  errored: number;
+  planned: number;
+  startedAt?: number;
+  usage: RunUsage;
+}
+interface RunnerOptions extends RunnerConfig {
+  clock?: () => number;
+}
+interface RunOptions {
+  config?: AlintConfig;
+  cwd?: string;
+  files?: string[];
+  modelOverride?: string;
+  progress?: ProgressReporter;
+  runner?: RunnerOptions;
+  setupConfig?: SetupConfig;
+}
+interface RunResult {
+  diagnostics: Diagnostic[];
+  usage: RunUsage;
+}
+interface RunStartPayload {
+  files?: ProgressFilePath[];
+  filesTotal: number;
+  planned: number;
+  rulesTotal: number;
+  startedAt?: number;
+}
+interface RunUsage {
+  inputTokens: number;
+  outputTokens: number;
+  records: InferenceUsageRecord[];
+  totalTokens: number;
+}
+interface TargetProgressPayload {
+  endedAt?: number;
+  path: ProgressPath;
+  startedAt?: number;
+}
+interface UsageProgressPayload {
+  path?: ProgressPath;
+  record: InferenceUsageRecord;
+  total: RunUsage;
+}
+//#endregion
+//#region src/core/run.d.ts
+interface AlintRunFailure {
+  filePath?: string;
+  message: string;
+  ruleId?: string;
+  target?: {
+    kind: ProgressTargetKind;
+    name?: string;
+  };
+}
+declare class AlintRunError extends Error {
+  readonly failure?: AlintRunFailure;
+  readonly result: RunResult;
+  constructor(message: string, result: RunResult, options?: {
+    cause?: unknown;
+    failure?: AlintRunFailure;
+  });
+}
+declare function runAlint(options?: RunOptions): Promise<RunResult>;
+//#endregion
+//#region src/core/source/js.d.ts
+interface JsSourceUnits {
+  classes: ClassUnit[];
+  functions: FunctionUnit[];
+}
+declare function extractJsSourceUnits(file: SourceFile): JsSourceUnits;
+//#endregion
+//#region src/core/source/runtime.d.ts
+declare function createSourceFile(path: string, text: string): SourceFile;
+declare function createSourceRuntime(): SourceRuntime;
+declare function sliceLines(file: SourceFile, range: LineRange): SourceText;
+declare function sliceRange(file: SourceFile, range: SourceRange): SourceText;
+//#endregion
+//#region src/dsl/define.d.ts
+declare function defineConfig(config: AlintConfig): AlintConfig;
+declare function definePlugin(plugin: PluginDefinition): PluginDefinition;
+declare function defineRule(rule: RuleDefinition): RuleDefinition;
+//#endregion
+//#region src/dsl/registry.d.ts
+declare function buildRuleRegistry(config: AlintConfig): RuleRegistry;
+//#endregion
+//#region src/models/resolve.d.ts
+declare function resolveModel(registry: SetupConfig, options?: ResolveModelOptions): ResolvedModel;
+//#endregion
+export { type AlintConfig, AlintRunError, type Awaitable, type ClassUnit, type Diagnostic, type DiagnosticDescriptor, type DiagnosticLocation, type DiagnosticProgressPayload, type EnabledRule, type FileProgressPayload, type FunctionUnit, type IgnoreConfig, type InferenceUsageRecord, type LineRange, type ModelRequirement, type ModelSize, type PluginDefinition, type ProgressFilePath, type ProgressPath, type ProgressReporter, type ProgressTargetKind, type ProviderDefinition, type ProviderType, type ResolveModelOptions, type ResolvedModel, type ResolvedProvider, 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 SourceText, type SourceUnit, type TargetProgressPayload, type UsageProgressPayload, buildRuleRegistry, createSourceFile, createSourceRuntime, defineConfig, definePlugin, defineRule, extractJsSourceUnits, resolveModel, runAlint, sliceLines, sliceRange };