@aiready/core 0.23.1 → 0.23.3

package/dist/parsers/typescript-parser.js

@@ -4,213 +4,239 @@
  * Parses TypeScript and JavaScript files using @typescript-eslint/typescript-estree
  */
 import { parse } from '@typescript-eslint/typescript-estree';
-import { Language, ParseError, } from '../types/language';
+import { Language, ParseError } from '../types/language';
 export class TypeScriptParser {
-    constructor() {
-        this.language = Language.TypeScript;
-        this.extensions = ['.ts', '.tsx', '.js', '.jsx'];
+  constructor() {
+    this.language = Language.TypeScript;
+    this.extensions = ['.ts', '.tsx', '.js', '.jsx'];
+  }
+  parse(code, filePath) {
+    try {
+      const isJavaScript = filePath.match(/\.jsx?$/i);
+      const ast = parse(code, {
+        loc: true,
+        range: true,
+        jsx: filePath.match(/\.[jt]sx$/i) !== null,
+        filePath,
+        sourceType: 'module',
+        ecmaVersion: 'latest',
+      });
+      const imports = this.extractImports(ast);
+      const exports = this.extractExports(ast, imports);
+      return {
+        exports,
+        imports,
+        language: isJavaScript ? Language.JavaScript : Language.TypeScript,
+        warnings: [],
+      };
+    } catch (error) {
+      const err = error;
+      throw new ParseError(
+        `Failed to parse ${filePath}: ${err.message}`,
+        filePath
+      );
     }
-    parse(code, filePath) {
-        try {
-            const isJavaScript = filePath.match(/\.jsx?$/i);
-            const ast = parse(code, {
-                loc: true,
-                range: true,
-                jsx: filePath.match(/\.[jt]sx$/i) !== null,
-                filePath,
-                sourceType: 'module',
-                ecmaVersion: 'latest',
-            });
-            const imports = this.extractImports(ast);
-            const exports = this.extractExports(ast, imports);
-            return {
-                exports,
-                imports,
-                language: isJavaScript ? Language.JavaScript : Language.TypeScript,
-                warnings: [],
-            };
+  }
+  getNamingConventions() {
+    return {
+      // camelCase for variables and functions
+      variablePattern: /^[a-z][a-zA-Z0-9]*$/,
+      functionPattern: /^[a-z][a-zA-Z0-9]*$/,
+      // PascalCase for classes
+      classPattern: /^[A-Z][a-zA-Z0-9]*$/,
+      // UPPER_CASE for constants
+      constantPattern: /^[A-Z][A-Z0-9_]*$/,
+      // Common exceptions (React hooks, etc.)
+      exceptions: ['__filename', '__dirname', '__esModule'],
+    };
+  }
+  canHandle(filePath) {
+    return this.extensions.some((ext) => filePath.toLowerCase().endsWith(ext));
+  }
+  extractImports(ast) {
+    const imports = [];
+    for (const node of ast.body) {
+      if (node.type === 'ImportDeclaration') {
+        const specifiers = [];
+        let isTypeOnly = false;
+        // @ts-ignore - importKind exists but not in types
+        if (node.importKind === 'type') {
+          isTypeOnly = true;
         }
-        catch (error) {
-            const err = error;
-            throw new ParseError(`Failed to parse ${filePath}: ${err.message}`, filePath);
+        for (const spec of node.specifiers) {
+          if (spec.type === 'ImportSpecifier') {
+            const imported = spec.imported;
+            const name =
+              imported.type === 'Identifier' ? imported.name : imported.value;
+            specifiers.push(name);
+          } else if (spec.type === 'ImportDefaultSpecifier') {
+            specifiers.push('default');
+          } else if (spec.type === 'ImportNamespaceSpecifier') {
+            specifiers.push('*');
+          }
         }
+        imports.push({
+          source: node.source.value,
+          specifiers,
+          isTypeOnly,
+          loc: node.loc
+            ? {
+                start: {
+                  line: node.loc.start.line,
+                  column: node.loc.start.column,
+                },
+                end: { line: node.loc.end.line, column: node.loc.end.column },
+              }
+            : undefined,
+        });
+      }
     }
-    getNamingConventions() {
-        return {
-            // camelCase for variables and functions
-            variablePattern: /^[a-z][a-zA-Z0-9]*$/,
-            functionPattern: /^[a-z][a-zA-Z0-9]*$/,
-            // PascalCase for classes
-            classPattern: /^[A-Z][a-zA-Z0-9]*$/,
-            // UPPER_CASE for constants
-            constantPattern: /^[A-Z][A-Z0-9_]*$/,
-            // Common exceptions (React hooks, etc.)
-            exceptions: ['__filename', '__dirname', '__esModule'],
-        };
-    }
-    canHandle(filePath) {
-        return this.extensions.some(ext => filePath.toLowerCase().endsWith(ext));
-    }
-    extractImports(ast) {
-        const imports = [];
-        for (const node of ast.body) {
-            if (node.type === 'ImportDeclaration') {
-                const specifiers = [];
-                let isTypeOnly = false;
-                // @ts-ignore - importKind exists but not in types
-                if (node.importKind === 'type') {
-                    isTypeOnly = true;
-                }
-                for (const spec of node.specifiers) {
-                    if (spec.type === 'ImportSpecifier') {
-                        const imported = spec.imported;
-                        const name = imported.type === 'Identifier' ? imported.name : imported.value;
-                        specifiers.push(name);
-                    }
-                    else if (spec.type === 'ImportDefaultSpecifier') {
-                        specifiers.push('default');
-                    }
-                    else if (spec.type === 'ImportNamespaceSpecifier') {
-                        specifiers.push('*');
-                    }
-                }
-                imports.push({
-                    source: node.source.value,
-                    specifiers,
-                    isTypeOnly,
-                    loc: node.loc
-                        ? {
-                            start: { line: node.loc.start.line, column: node.loc.start.column },
-                            end: { line: node.loc.end.line, column: node.loc.end.column },
-                        }
-                        : undefined,
-                });
-            }
+    return imports;
+  }
+  extractExports(ast, imports) {
+    const exports = [];
+    const importedNames = new Set(
+      imports.flatMap((imp) =>
+        imp.specifiers.filter((s) => s !== '*' && s !== 'default')
+      )
+    );
+    for (const node of ast.body) {
+      if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+        const extracted = this.extractFromDeclaration(
+          node.declaration,
+          importedNames
+        );
+        exports.push(...extracted);
+      } else if (node.type === 'ExportDefaultDeclaration') {
+        // Default export
+        let name = 'default';
+        let type = 'default';
+        if (
+          node.declaration.type === 'FunctionDeclaration' &&
+          node.declaration.id
+        ) {
+          name = node.declaration.id.name;
+          type = 'function';
+        } else if (
+          node.declaration.type === 'ClassDeclaration' &&
+          node.declaration.id
+        ) {
+          name = node.declaration.id.name;
+          type = 'class';
         }
-        return imports;
+        exports.push({
+          name,
+          type,
+          loc: node.loc
+            ? {
+                start: {
+                  line: node.loc.start.line,
+                  column: node.loc.start.column,
+                },
+                end: { line: node.loc.end.line, column: node.loc.end.column },
+              }
+            : undefined,
+        });
+      }
     }
-    extractExports(ast, imports) {
-        const exports = [];
-        const importedNames = new Set(imports.flatMap(imp => imp.specifiers.filter(s => s !== '*' && s !== 'default')));
-        for (const node of ast.body) {
-            if (node.type === 'ExportNamedDeclaration' && node.declaration) {
-                const extracted = this.extractFromDeclaration(node.declaration, importedNames);
-                exports.push(...extracted);
+    return exports;
+  }
+  extractFromDeclaration(declaration, importedNames) {
+    const exports = [];
+    if (declaration.type === 'FunctionDeclaration' && declaration.id) {
+      exports.push({
+        name: declaration.id.name,
+        type: 'function',
+        parameters: declaration.params.map((p) =>
+          p.type === 'Identifier' ? p.name : 'unknown'
+        ),
+        loc: declaration.loc
+          ? {
+              start: {
+                line: declaration.loc.start.line,
+                column: declaration.loc.start.column,
+              },
+              end: {
+                line: declaration.loc.end.line,
+                column: declaration.loc.end.column,
+              },
             }
-            else if (node.type === 'ExportDefaultDeclaration') {
-                // Default export
-                let name = 'default';
-                let type = 'default';
-                if (node.declaration.type === 'FunctionDeclaration' &&
-                    node.declaration.id) {
-                    name = node.declaration.id.name;
-                    type = 'function';
-                }
-                else if (node.declaration.type === 'ClassDeclaration' &&
-                    node.declaration.id) {
-                    name = node.declaration.id.name;
-                    type = 'class';
-                }
-                exports.push({
-                    name,
-                    type,
-                    loc: node.loc
-                        ? {
-                            start: { line: node.loc.start.line, column: node.loc.start.column },
-                            end: { line: node.loc.end.line, column: node.loc.end.column },
-                        }
-                        : undefined,
-                });
+          : undefined,
+      });
+    } else if (declaration.type === 'ClassDeclaration' && declaration.id) {
+      exports.push({
+        name: declaration.id.name,
+        type: 'class',
+        loc: declaration.loc
+          ? {
+              start: {
+                line: declaration.loc.start.line,
+                column: declaration.loc.start.column,
+              },
+              end: {
+                line: declaration.loc.end.line,
+                column: declaration.loc.end.column,
+              },
             }
-        }
-        return exports;
-    }
-    extractFromDeclaration(declaration, importedNames) {
-        const exports = [];
-        if (declaration.type === 'FunctionDeclaration' && declaration.id) {
-            exports.push({
-                name: declaration.id.name,
-                type: 'function',
-                parameters: declaration.params.map((p) => p.type === 'Identifier' ? p.name : 'unknown'),
-                loc: declaration.loc
-                    ? {
-                        start: {
-                            line: declaration.loc.start.line,
-                            column: declaration.loc.start.column,
-                        },
-                        end: { line: declaration.loc.end.line, column: declaration.loc.end.column },
-                    }
-                    : undefined,
-            });
-        }
-        else if (declaration.type === 'ClassDeclaration' && declaration.id) {
-            exports.push({
-                name: declaration.id.name,
-                type: 'class',
-                loc: declaration.loc
-                    ? {
-                        start: {
-                            line: declaration.loc.start.line,
-                            column: declaration.loc.start.column,
-                        },
-                        end: { line: declaration.loc.end.line, column: declaration.loc.end.column },
-                    }
-                    : undefined,
-            });
-        }
-        else if (declaration.type === 'VariableDeclaration') {
-            for (const declarator of declaration.declarations) {
-                if (declarator.id.type === 'Identifier') {
-                    exports.push({
-                        name: declarator.id.name,
-                        type: 'const',
-                        loc: declarator.loc
-                            ? {
-                                start: {
-                                    line: declarator.loc.start.line,
-                                    column: declarator.loc.start.column,
-                                },
-                                end: {
-                                    line: declarator.loc.end.line,
-                                    column: declarator.loc.end.column,
-                                },
-                            }
-                            : undefined,
-                    });
+          : undefined,
+      });
+    } else if (declaration.type === 'VariableDeclaration') {
+      for (const declarator of declaration.declarations) {
+        if (declarator.id.type === 'Identifier') {
+          exports.push({
+            name: declarator.id.name,
+            type: 'const',
+            loc: declarator.loc
+              ? {
+                  start: {
+                    line: declarator.loc.start.line,
+                    column: declarator.loc.start.column,
+                  },
+                  end: {
+                    line: declarator.loc.end.line,
+                    column: declarator.loc.end.column,
+                  },
                 }
-            }
+              : undefined,
+          });
         }
-        else if (declaration.type === 'TSTypeAliasDeclaration') {
-            exports.push({
-                name: declaration.id.name,
-                type: 'type',
-                loc: declaration.loc
-                    ? {
-                        start: {
-                            line: declaration.loc.start.line,
-                            column: declaration.loc.start.column,
-                        },
-                        end: { line: declaration.loc.end.line, column: declaration.loc.end.column },
-                    }
-                    : undefined,
-            });
-        }
-        else if (declaration.type === 'TSInterfaceDeclaration') {
-            exports.push({
-                name: declaration.id.name,
-                type: 'interface',
-                loc: declaration.loc
-                    ? {
-                        start: {
-                            line: declaration.loc.start.line,
-                            column: declaration.loc.start.column,
-                        },
-                        end: { line: declaration.loc.end.line, column: declaration.loc.end.column },
-                    }
-                    : undefined,
-            });
-        }
-        return exports;
+      }
+    } else if (declaration.type === 'TSTypeAliasDeclaration') {
+      exports.push({
+        name: declaration.id.name,
+        type: 'type',
+        loc: declaration.loc
+          ? {
+              start: {
+                line: declaration.loc.start.line,
+                column: declaration.loc.start.column,
+              },
+              end: {
+                line: declaration.loc.end.line,
+                column: declaration.loc.end.column,
+              },
+            }
+          : undefined,
+      });
+    } else if (declaration.type === 'TSInterfaceDeclaration') {
+      exports.push({
+        name: declaration.id.name,
+        type: 'interface',
+        loc: declaration.loc
+          ? {
+              start: {
+                line: declaration.loc.start.line,
+                column: declaration.loc.start.column,
+              },
+              end: {
+                line: declaration.loc.end.line,
+                column: declaration.loc.end.column,
+              },
+            }
+          : undefined,
+      });
     }
+    return exports;
+  }
 }
-//# sourceMappingURL=typescript-parser.js.map
+//# sourceMappingURL=typescript-parser.js.map

package/dist/scoring.d.ts

@@ -5,52 +5,52 @@
  * Each tool contributes a 0-100 score with configurable weights.
  */
 export interface ToolScoringOutput {
-    /** Unique tool identifier (e.g., "pattern-detect") */
-    toolName: string;
-    /** Normalized 0-100 score for this tool */
-    score: number;
-    /** Raw metrics used to calculate the score */
-    rawMetrics: Record<string, any>;
-    /** Factors that influenced the score */
-    factors: Array<{
-        name: string;
-        impact: number;
-        description: string;
-    }>;
-    /** Actionable recommendations with estimated impact */
-    recommendations: Array<{
-        action: string;
-        estimatedImpact: number;
-        priority: 'high' | 'medium' | 'low';
-    }>;
+  /** Unique tool identifier (e.g., "pattern-detect") */
+  toolName: string;
+  /** Normalized 0-100 score for this tool */
+  score: number;
+  /** Raw metrics used to calculate the score */
+  rawMetrics: Record<string, any>;
+  /** Factors that influenced the score */
+  factors: Array<{
+    name: string;
+    impact: number;
+    description: string;
+  }>;
+  /** Actionable recommendations with estimated impact */
+  recommendations: Array<{
+    action: string;
+    estimatedImpact: number;
+    priority: 'high' | 'medium' | 'low';
+  }>;
 }
 export interface ScoringResult {
-    /** Overall AI Readiness Score (0-100) */
-    overall: number;
-    /** Rating category */
-    rating: 'Excellent' | 'Good' | 'Fair' | 'Needs Work' | 'Critical';
-    /** Timestamp of score calculation */
-    timestamp: string;
-    /** Tools that contributed to this score */
-    toolsUsed: string[];
-    /** Breakdown by tool */
-    breakdown: ToolScoringOutput[];
-    /** Calculation details */
-    calculation: {
-        formula: string;
-        weights: Record<string, number>;
-        normalized: string;
-    };
+  /** Overall AI Readiness Score (0-100) */
+  overall: number;
+  /** Rating category */
+  rating: 'Excellent' | 'Good' | 'Fair' | 'Needs Work' | 'Critical';
+  /** Timestamp of score calculation */
+  timestamp: string;
+  /** Tools that contributed to this score */
+  toolsUsed: string[];
+  /** Breakdown by tool */
+  breakdown: ToolScoringOutput[];
+  /** Calculation details */
+  calculation: {
+    formula: string;
+    weights: Record<string, number>;
+    normalized: string;
+  };
 }
 export interface ScoringConfig {
-    /** Minimum passing score (exit code 1 if below) */
-    threshold?: number;
-    /** Show detailed breakdown in output */
-    showBreakdown?: boolean;
-    /** Path to baseline JSON for comparison */
-    compareBaseline?: string;
-    /** Auto-save score to this path */
-    saveTo?: string;
+  /** Minimum passing score (exit code 1 if below) */
+  threshold?: number;
+  /** Show detailed breakdown in output */
+  showBreakdown?: boolean;
+  /** Path to baseline JSON for comparison */
+  compareBaseline?: string;
+  /** Auto-save score to this path */
+  saveTo?: string;
 }
 /**
  * Default weights for known tools.
@@ -72,13 +72,19 @@ export declare function normalizeToolName(shortName: string): string;
  * 3. Default weight
  * 4. 10 (for unknown tools)
  */
-export declare function getToolWeight(toolName: string, toolConfig?: {
+export declare function getToolWeight(
+  toolName: string,
+  toolConfig?: {
     scoreWeight?: number;
-}, cliOverride?: number): number;
+  },
+  cliOverride?: number
+): number;
 /**
  * Parse weight string from CLI (e.g., "patterns:50,context:30")
  */
-export declare function parseWeightString(weightStr?: string): Map<string, number>;
+export declare function parseWeightString(
+  weightStr?: string
+): Map<string, number>;
 /**
  * Calculate overall AI Readiness Score from multiple tool scores.
  *
@@ -87,7 +93,11 @@ export declare function parseWeightString(weightStr?: string): Map<string, numbe
  * This allows dynamic composition - score adjusts automatically
  * based on which tools actually ran.
  */
-export declare function calculateOverallScore(toolOutputs: Map<string, ToolScoringOutput>, config?: any, cliWeights?: Map<string, number>): ScoringResult;
+export declare function calculateOverallScore(
+  toolOutputs: Map<string, ToolScoringOutput>,
+  config?: any,
+  cliWeights?: Map<string, number>
+): ScoringResult;
 /**
  * Convert numeric score to rating category
  */
@@ -96,8 +106,8 @@ export declare function getRating(score: number): ScoringResult['rating'];
  * Get rating emoji and color for display
  */
 export declare function getRatingDisplay(rating: ScoringResult['rating']): {
-    emoji: string;
-    color: string;
+  emoji: string;
+  color: string;
 };
 /**
  * Format score for display with rating
@@ -107,4 +117,4 @@ export declare function formatScore(result: ScoringResult): string;
  * Format individual tool score for display
  */
 export declare function formatToolScore(output: ToolScoringOutput): string;
-//# sourceMappingURL=scoring.d.ts.map
+//# sourceMappingURL=scoring.d.ts.map