@alint-js/plugin 0.0.29

package/dist/index.d.mts

@@ -0,0 +1,310 @@
+//#region ../core/dist/types-DSvXUVZ7.d.mts
+//#region src/core/source/types.d.ts
+type ClassTarget = SourceTargetOfKind<'class'>;
+type FileTarget = SourceTargetOfKind<'file'>;
+type FunctionTarget = SourceTargetOfKind<'function'>;
+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 & {});
+type SourceTargetOfKind<Kind extends SourceTargetKind> = Omit<SourceTarget, 'kind'> & {
+  kind: Kind;
+};
+interface SourceTargetOrigin {
+  physicalPath: string;
+  range?: SourceRange;
+  virtualPath?: string;
+}
+interface SourceText {
+  filePath: string;
+  loc: SourceLocation;
+  text: string;
+}
+//#endregion
+//#region ../core/dist/types-CMLoj9J9.d.mts
+//#region src/config/types.d.ts
+type ModelSize = 'large' | 'medium' | 'small';
+interface RunnerCacheConfig {
+  enabled?: boolean;
+  location?: string;
+}
+interface RunnerConfig {
+  /** Retries after the initial attempt for replay-safe agent failures. @default 2 */
+  agentRetries?: number;
+  cache?: boolean | RunnerCacheConfig;
+  fileConcurrency?: number;
+  ruleConcurrency?: number;
+  stats?: boolean | RunnerStatsConfig;
+  timeoutMs?: number;
+}
+interface RunnerStatsConfig {
+  enabled?: boolean;
+  location?: string;
+  retentionMonths?: number;
+}
+//#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';
+}
+//#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/dsl/types.d.ts
+type AlintConfig = readonly AlintConfigInput[];
+type AlintConfigExtends = AlintConfigInput | string;
+type AlintConfigInput = AlintConfigItem | readonly AlintConfigInput[];
+interface AlintConfigItem {
+  agent?: AgentAdapter;
+  basePath?: string;
+  directories?: readonly (readonly string[] | 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 DirectoryTarget {
+  kind: 'directory';
+  path: string;
+}
+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[]>;
+}
+interface ProjectTarget {
+  files: SourceFile[];
+  kind: 'project';
+  root: string;
+  targets: SourceTarget[];
+}
+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>;
+  /**
+   * Cancels the run. Forward it to anything long-running a rule starts, so cancelling stops
+   * the work instead of letting it finish and bill.
+   *
+   * `ctx.agent` already injects it, and `generateStructured` accepts it as `signal`.
+   */
+  signal?: AbortSignal;
+  src: SourceRuntime;
+}
+interface RuleDefinition {
+  cache?: RuleCacheConfig;
+  /** Additional stable rule inputs, such as imported prompts, that invalidate cached results when changed. */
+  cacheKey?: unknown;
+  create: (context: RuleContext) => RuleHandlers;
+  model?: ModelRequirement;
+}
+type RuleHandlers = RuleSpecializedHandlers | RuleWithHandler;
+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';
+interface RuleSpecializedHandlers {
+  onTargetClass?: (target: ClassTarget) => Awaitable<void>;
+  onTargetDirectory?: (target: DirectoryTarget) => Awaitable<void>;
+  onTargetFile?: (target: FileTarget) => Awaitable<void>;
+  onTargetFunction?: (target: FunctionTarget) => Awaitable<void>;
+  onTargetProject?: (target: ProjectTarget) => Awaitable<void>;
+  onTargetWith?: never;
+}
+interface RuleWithHandler {
+  onTargetClass?: never;
+  onTargetDirectory?: never;
+  onTargetFile?: never;
+  onTargetFunction?: never;
+  onTargetProject?: never;
+  onTargetWith: (target: Target) => Awaitable<void>;
+}
+type Target = DirectoryTarget | ProjectTarget | SourceTarget;
+//#endregion
+//#region src/index.d.ts
+declare function defineConfig(config: readonly AlintConfigInput[]): AlintConfig;
+declare function definePlugin(plugin: PluginDefinition): PluginDefinition;
+declare function defineRule(rule: RuleDefinition): RuleDefinition;
+//#endregion
+export { type AlintConfig, type AlintConfigExtends, type AlintConfigInput, type AlintConfigItem, type AlintLinterOptions, type Awaitable, type ClassTarget, type DiagnosticDescriptor, type DiagnosticLocation, type DirectoryTarget, type EnabledRule, type FileTarget, type FunctionTarget, type IgnoreConfig, type LanguageContext, type LanguageDefinition, type LineRange, type ModelRequirement, type PluginDefinition, type ProcessedSource, type ProcessedSourceOrigin, type ProcessorContext, type ProcessorDefinition, type ProcessorPostprocessContext, type ProjectTarget, type ResolvedModel, type ResolvedProvider, type RuleCacheConfig, type RuleConfigEntry, type RuleContext, type RuleDefinition, type RuleHandlers, type RuleInferenceUsageRecord, type RuleRegistry, type RuleSeverity, type RuleSpecializedHandlers, type RuleWithHandler, type SourceFile, type SourceLocation, type SourcePosition, type SourceRange, type SourceRuntime, type SourceTarget, type SourceTargetKind, type SourceTargetOfKind, type SourceTargetOrigin, type SourceText, type Target, defineConfig, definePlugin, defineRule };

package/dist/index.mjs

@@ -0,0 +1,12 @@
+//#region src/index.ts
+function defineConfig(config) {
+	return config;
+}
+function definePlugin(plugin) {
+	return plugin;
+}
+function defineRule(rule) {
+	return rule;
+}
+//#endregion
+export { defineConfig, definePlugin, defineRule };

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@alint-js/plugin",
+  "type": "module",
+  "version": "0.0.29",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@alint-js/core": "0.0.29"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}