deep-slop 1.4.1

package/dist/index.d.ts

@@ -0,0 +1,233 @@
+import { z } from "zod";
+
+//#region src/config/schema.d.ts
+/**
+ * Full DeepSlop configuration schema — the final validated shape
+ * after merging with defaults. All sections are required.
+ */
+declare const DeepSlopConfigSchema: z.ZodObject<{
+  engines: z.ZodRecord<z.ZodString, z.ZodBoolean>;
+  quality: z.ZodObject<{
+    maxFunctionLoc: z.ZodNumber;
+    maxFileLoc: z.ZodNumber;
+    maxNesting: z.ZodNumber;
+    maxParams: z.ZodNumber;
+    maxCyclomatic: z.ZodNumber;
+    maxCoupling: z.ZodNumber;
+  }, z.core.$loose>;
+  security: z.ZodObject<{
+    audit: z.ZodBoolean;
+    auditTimeout: z.ZodNumber;
+    owasp: z.ZodBoolean;
+  }, z.core.$loose>;
+  imports: z.ZodObject<{
+    suggestAlternatives: z.ZodBoolean;
+    optimizeBarrels: z.ZodBoolean;
+    validateAliases: z.ZodBoolean;
+    buildGraph: z.ZodBoolean;
+    maxCircularDepth: z.ZodNumber;
+  }, z.core.$loose>;
+  types: z.ZodObject<{
+    flagAsAny: z.ZodBoolean;
+    suggestTypes: z.ZodBoolean;
+    flagDoubleAssertion: z.ZodBoolean;
+  }, z.core.$loose>;
+  deadCode: z.ZodObject<{
+    unreachableBranches: z.ZodBoolean;
+    unusedExports: z.ZodBoolean;
+    unusedVariables: z.ZodBoolean;
+  }, z.core.$loose>;
+  i18n: z.ZodObject<{
+    hardcodedStrings: z.ZodBoolean;
+    validateKeys: z.ZodBoolean;
+  }, z.core.$loose>;
+  scoring: z.ZodDefault<z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+      logarithmic: "logarithmic";
+      linear: "linear";
+    }>>;
+    smoothing: z.ZodDefault<z.ZodNumber>;
+    maxPerRule: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+  telemetry: z.ZodDefault<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  exclude: z.ZodArray<z.ZodString>;
+  ignore: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  ci: z.ZodDefault<z.ZodObject<{
+    failBelow: z.ZodDefault<z.ZodNumber>;
+    format: z.ZodDefault<z.ZodEnum<{
+      json: "json";
+      human: "human";
+      sarif: "sarif";
+    }>>;
+    failOnErrors: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  rules: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodEnum<{
+    error: "error";
+    warning: "warning";
+    info: "info";
+    off: "off";
+  }>>>;
+}, z.core.$loose>;
+/** Inferred TypeScript type from the Zod schema */
+type DeepSlopConfig = z.infer<typeof DeepSlopConfigSchema>;
+//#endregion
+//#region src/config/defaults.d.ts
+/** Default configuration matching the canonical values */
+declare const DEFAULT_CONFIG: DeepSlopConfig;
+//#endregion
+//#region src/types/index.d.ts
+/** All built-in engine identifiers (18 built-in) */
+type BuiltinEngineName = "ast-slop" | "import-intelligence" | "dead-flow" | "type-safety" | "syntax-deep" | "security-deep" | "arch-constraints" | "dup-detect" | "perf-hints" | "i18n-lint" | "config-lint" | "meta-quality" | "arch-rules" | "lint-external" | "knip" | "format-lint" | "framework-lint" | "markup-lint";
+/** Engine name — built-in or plugin-provided */
+type EngineName = BuiltinEngineName | (string & {});
+/** Runtime list of all 18 built-in engine names */
+declare const ALL_ENGINE_NAMES: readonly EngineName[];
+/** Diagnostic severity levels */
+type Severity = "error" | "warning" | "info" | "suggestion";
+/** Language targets */
+type Language = "typescript" | "javascript" | "python" | "go" | "rust" | "ruby" | "php" | "java" | "tsx" | "jsx" | "csharp" | "swift";
+/** Framework hints detected from project */
+type Framework = "react" | "next.js" | "vue" | "svelte" | "angular" | "express" | "fastify" | "nestjs" | "django" | "flask" | "fastapi" | "rails" | "laravel" | "none";
+/** Category grouping for diagnostics */
+type Category = "ai-slop" | "imports" | "dead-code" | "types" | "syntax" | "security" | "architecture" | "duplication" | "performance" | "i18n" | "config" | "style";
+interface Diagnostic {
+  /** File path relative to root */
+  filePath: string;
+  /** Engine that produced this diagnostic */
+  engine: EngineName;
+  /** Rule identifier (e.g. "ai-slop/narrative-comment") */
+  rule: string;
+  /** Severity level */
+  severity: Severity;
+  /** Human-readable message */
+  message: string;
+  /** Help text / fix suggestion */
+  help: string;
+  /** Line number (1-based) */
+  line: number;
+  /** Column number (1-based) */
+  column: number;
+  /** Category for grouping */
+  category: Category;
+  /** Whether this can be auto-fixed */
+  fixable: boolean;
+  /** Suggested fix (code diff or replacement) */
+  suggestion?: Suggestion;
+  /** Additional structured detail */
+  detail?: Record<string, unknown>;
+}
+interface Suggestion {
+  /** Type of suggestion */
+  type: "replace" | "insert" | "delete" | "refactor";
+  /** The replacement text (for replace/insert) */
+  text: string;
+  /** Range to replace */
+  range?: {
+    startLine: number;
+    startCol: number;
+    endLine: number;
+    endCol: number;
+  };
+  /** Confidence level 0-1 */
+  confidence: number;
+  /** Why this suggestion is better */
+  reason: string;
+}
+interface EngineResult {
+  /** Engine name */
+  engine: EngineName;
+  /** Diagnostics found */
+  diagnostics: Diagnostic[];
+  /** Time taken in ms */
+  elapsed: number;
+  /** Whether engine was skipped */
+  skipped: boolean;
+  /** Why it was skipped */
+  skipReason?: string;
+}
+interface EngineContext {
+  /** Root directory of the project */
+  rootDirectory: string;
+  /** Detected languages */
+  languages: Language[];
+  /** Detected frameworks */
+  frameworks: Framework[];
+  /** Specific files to scan (if --include or --changes) */
+  files?: string[];
+  /** Which tools are installed (keyed by name) */
+  installedTools: Record<string, string | boolean>;
+  /** Engine configuration */
+  config: DeepSlopConfig;
+  /** Diff scope description, e.g. "3 changed vs origin/main" */
+  diffScope?: string;
+}
+interface Engine {
+  /** Engine identifier */
+  name: EngineName;
+  /** Human-readable description */
+  description: string;
+  /** Languages this engine supports */
+  supportedLanguages: Language[];
+  /** Run the engine and produce diagnostics */
+  run(context: EngineContext): Promise<EngineResult>;
+  /** Auto-fix diagnostics (optional) */
+  fix?(diagnostics: Diagnostic[], context: EngineContext): Promise<FixResult>;
+}
+interface FixResult {
+  /** Number of diagnostics fixed */
+  fixed: number;
+  /** Diagnostics that couldn't be fixed */
+  remaining: Diagnostic[];
+  /** Files that were modified */
+  modifiedFiles: string[];
+}
+interface ScanResult {
+  /** Per-engine results */
+  engines: EngineResult[];
+  /** Aggregate score 0-100, or null if majority of files are in unsupported languages */
+  score: number | null;
+  /** Whether the score is meaningful (false if >80% of files are in unsupported languages) */
+  scoreable: boolean;
+  /** Per-category breakdown */
+  categoryScores: Record<Category, number>;
+  /** Total diagnostics */
+  totalDiagnostics: number;
+  /** By severity */
+  bySeverity: Record<Severity, number>;
+  /** By engine */
+  byEngine: Record<EngineName, number>;
+  /** Number of diagnostics suppressed by deep-slop-ignore directives */
+  suppressedCount: number;
+  /** Project metadata */
+  meta: {
+    rootDirectory: string;
+    languages: Language[];
+    frameworks: Framework[];
+    filesScanned: number;
+    elapsed: number; /** Diff scope description, e.g. "3 changed vs origin/main" */
+    diffScope?: string;
+  };
+}
+//#endregion
+//#region src/engines/orchestrator.d.ts
+interface OrchestratorCallbacks {
+  onEngineStart?: (name: EngineName) => void;
+  onEngineComplete?: (result: EngineResult) => void;
+  onProgress?: (completed: number, total: number) => void;
+}
+/** Run selected engines and produce aggregated scan result */
+declare function runScan(context: EngineContext, callbacks?: OrchestratorCallbacks): Promise<ScanResult>;
+/** Run auto-fix for a specific engine */
+declare function runFix(engineName: EngineName, diagnostics: Diagnostic[], context: EngineContext): Promise<FixResult | null>;
+//#endregion
+//#region src/utils/discover.d.ts
+/** Detect languages from file extensions in the project */
+declare function detectLanguages(rootDir: string): Promise<Language[]>;
+/** Detect frameworks from config files and dependencies */
+declare function detectFrameworks(rootDir: string): Promise<Framework[]>;
+/** Collect all source files to scan */
+declare function collectFiles(rootDir: string, languages: Language[], excludePatterns?: string[], includeFiles?: string[], ignorePatterns?: string[], includePatterns?: string[]): Promise<string[]>;
+//#endregion
+export { ALL_ENGINE_NAMES, type BuiltinEngineName, type Category, DEFAULT_CONFIG, type DeepSlopConfig, type Diagnostic, type Engine, type EngineContext, type EngineName, type EngineResult, type FixResult, type Framework, type Language, type ScanResult, type Severity, type Suggestion, collectFiles, detectFrameworks, detectLanguages, runFix, runScan };