@aiready/core 0.23.2 → 0.23.3

package/dist/scoring.js

@@ -9,27 +9,27 @@
  * New tools get weight of 10 if not specified.
  */
 export const DEFAULT_TOOL_WEIGHTS = {
-    'pattern-detect': 40,
-    'context-analyzer': 35,
-    'consistency': 25,
-    'doc-drift': 20,
-    'deps': 15,
+  'pattern-detect': 40,
+  'context-analyzer': 35,
+  consistency: 25,
+  'doc-drift': 20,
+  deps: 15,
 };
 /**
  * Tool name normalization map (shorthand -> full name)
  */
 export const TOOL_NAME_MAP = {
-    'patterns': 'pattern-detect',
-    'context': 'context-analyzer',
-    'consistency': 'consistency',
-    'doc-drift': 'doc-drift',
-    'deps': 'deps',
+  patterns: 'pattern-detect',
+  context: 'context-analyzer',
+  consistency: 'consistency',
+  'doc-drift': 'doc-drift',
+  deps: 'deps',
 };
 /**
  * Normalize tool name from shorthand to full name
  */
 export function normalizeToolName(shortName) {
-    return TOOL_NAME_MAP[shortName] || shortName;
+  return TOOL_NAME_MAP[shortName] || shortName;
 }
 /**
  * Get tool weight with fallback priority:
@@ -39,37 +39,37 @@ export function normalizeToolName(shortName) {
  * 4. 10 (for unknown tools)
  */
 export function getToolWeight(toolName, toolConfig, cliOverride) {
-    // CLI override has highest priority
-    if (cliOverride !== undefined) {
-        return cliOverride;
-    }
-    // Check tool's own config
-    if (toolConfig?.scoreWeight !== undefined) {
-        return toolConfig.scoreWeight;
-    }
-    // Fall back to defaults
-    return DEFAULT_TOOL_WEIGHTS[toolName] || 10;
+  // CLI override has highest priority
+  if (cliOverride !== undefined) {
+    return cliOverride;
+  }
+  // Check tool's own config
+  if (toolConfig?.scoreWeight !== undefined) {
+    return toolConfig.scoreWeight;
+  }
+  // Fall back to defaults
+  return DEFAULT_TOOL_WEIGHTS[toolName] || 10;
 }
 /**
  * Parse weight string from CLI (e.g., "patterns:50,context:30")
  */
 export function parseWeightString(weightStr) {
-    const weights = new Map();
-    if (!weightStr) {
-        return weights;
-    }
-    const pairs = weightStr.split(',');
-    for (const pair of pairs) {
-        const [toolShortName, weightStr] = pair.split(':');
-        if (toolShortName && weightStr) {
-            const toolName = normalizeToolName(toolShortName.trim());
-            const weight = parseInt(weightStr.trim(), 10);
-            if (!isNaN(weight) && weight > 0) {
-                weights.set(toolName, weight);
-            }
-        }
-    }
+  const weights = new Map();
+  if (!weightStr) {
     return weights;
+  }
+  const pairs = weightStr.split(',');
+  for (const pair of pairs) {
+    const [toolShortName, weightStr] = pair.split(':');
+    if (toolShortName && weightStr) {
+      const toolName = normalizeToolName(toolShortName.trim());
+      const weight = parseInt(weightStr.trim(), 10);
+      if (!isNaN(weight) && weight > 0) {
+        weights.set(toolName, weight);
+      }
+    }
+  }
+  return weights;
 }
 /**
  * Calculate overall AI Readiness Score from multiple tool scores.
@@ -80,116 +80,118 @@ export function parseWeightString(weightStr) {
  * based on which tools actually ran.
  */
 export function calculateOverallScore(toolOutputs, config, cliWeights) {
-    if (toolOutputs.size === 0) {
-        throw new Error('No tool outputs provided for scoring');
-    }
-    // Build weights map with priority: CLI > config > defaults
-    const weights = new Map();
-    for (const [toolName] of toolOutputs.entries()) {
-        const cliWeight = cliWeights?.get(toolName);
-        const configWeight = config?.tools?.[toolName]?.scoreWeight;
-        const weight = cliWeight ?? configWeight ?? DEFAULT_TOOL_WEIGHTS[toolName] ?? 10;
-        weights.set(toolName, weight);
+  if (toolOutputs.size === 0) {
+    throw new Error('No tool outputs provided for scoring');
+  }
+  // Build weights map with priority: CLI > config > defaults
+  const weights = new Map();
+  for (const [toolName] of toolOutputs.entries()) {
+    const cliWeight = cliWeights?.get(toolName);
+    const configWeight = config?.tools?.[toolName]?.scoreWeight;
+    const weight =
+      cliWeight ?? configWeight ?? DEFAULT_TOOL_WEIGHTS[toolName] ?? 10;
+    weights.set(toolName, weight);
+  }
+  // Calculate weighted sum and total weight
+  let weightedSum = 0;
+  let totalWeight = 0;
+  const breakdown = [];
+  const toolsUsed = [];
+  const calculationWeights = {};
+  for (const [toolName, output] of toolOutputs.entries()) {
+    const weight = weights.get(toolName) || 10;
+    const weightedScore = output.score * weight;
+    weightedSum += weightedScore;
+    totalWeight += weight;
+    toolsUsed.push(toolName);
+    calculationWeights[toolName] = weight;
+    breakdown.push(output);
+  }
+  // Calculate final score
+  const overall = Math.round(weightedSum / totalWeight);
+  // Determine rating
+  const rating = getRating(overall);
+  // Build formula string
+  const formulaParts = Array.from(toolOutputs.entries()).map(
+    ([name, output]) => {
+      const w = weights.get(name) || 10;
+      return `(${output.score} × ${w})`;
     }
-    // Calculate weighted sum and total weight
-    let weightedSum = 0;
-    let totalWeight = 0;
-    const breakdown = [];
-    const toolsUsed = [];
-    const calculationWeights = {};
-    for (const [toolName, output] of toolOutputs.entries()) {
-        const weight = weights.get(toolName) || 10;
-        const weightedScore = output.score * weight;
-        weightedSum += weightedScore;
-        totalWeight += weight;
-        toolsUsed.push(toolName);
-        calculationWeights[toolName] = weight;
-        breakdown.push(output);
-    }
-    // Calculate final score
-    const overall = Math.round(weightedSum / totalWeight);
-    // Determine rating
-    const rating = getRating(overall);
-    // Build formula string
-    const formulaParts = Array.from(toolOutputs.entries())
-        .map(([name, output]) => {
-        const w = weights.get(name) || 10;
-        return `(${output.score} × ${w})`;
-    });
-    const formulaStr = `[${formulaParts.join(' + ')}] / ${totalWeight} = ${overall}`;
-    return {
-        overall,
-        rating,
-        timestamp: new Date().toISOString(),
-        toolsUsed,
-        breakdown,
-        calculation: {
-            formula: formulaStr,
-            weights: calculationWeights,
-            normalized: formulaStr,
-        },
-    };
+  );
+  const formulaStr = `[${formulaParts.join(' + ')}] / ${totalWeight} = ${overall}`;
+  return {
+    overall,
+    rating,
+    timestamp: new Date().toISOString(),
+    toolsUsed,
+    breakdown,
+    calculation: {
+      formula: formulaStr,
+      weights: calculationWeights,
+      normalized: formulaStr,
+    },
+  };
 }
 /**
  * Convert numeric score to rating category
  */
 export function getRating(score) {
-    if (score >= 90)
-        return 'Excellent';
-    if (score >= 75)
-        return 'Good';
-    if (score >= 60)
-        return 'Fair';
-    if (score >= 40)
-        return 'Needs Work';
-    return 'Critical';
+  if (score >= 90) return 'Excellent';
+  if (score >= 75) return 'Good';
+  if (score >= 60) return 'Fair';
+  if (score >= 40) return 'Needs Work';
+  return 'Critical';
 }
 /**
  * Get rating emoji and color for display
  */
 export function getRatingDisplay(rating) {
-    switch (rating) {
-        case 'Excellent':
-            return { emoji: '✅', color: 'green' };
-        case 'Good':
-            return { emoji: '👍', color: 'blue' };
-        case 'Fair':
-            return { emoji: '⚠️', color: 'yellow' };
-        case 'Needs Work':
-            return { emoji: '🔨', color: 'orange' };
-        case 'Critical':
-            return { emoji: '❌', color: 'red' };
-    }
+  switch (rating) {
+    case 'Excellent':
+      return { emoji: '✅', color: 'green' };
+    case 'Good':
+      return { emoji: '👍', color: 'blue' };
+    case 'Fair':
+      return { emoji: '⚠️', color: 'yellow' };
+    case 'Needs Work':
+      return { emoji: '🔨', color: 'orange' };
+    case 'Critical':
+      return { emoji: '❌', color: 'red' };
+  }
 }
 /**
  * Format score for display with rating
  */
 export function formatScore(result) {
-    const { emoji, color } = getRatingDisplay(result.rating);
-    return `${result.overall}/100 (${result.rating}) ${emoji}`;
+  const { emoji, color } = getRatingDisplay(result.rating);
+  return `${result.overall}/100 (${result.rating}) ${emoji}`;
 }
 /**
  * Format individual tool score for display
  */
 export function formatToolScore(output) {
-    let result = `  Score: ${output.score}/100\n\n`;
-    if (output.factors && output.factors.length > 0) {
-        result += `  Factors:\n`;
-        output.factors.forEach(factor => {
-            const impactSign = factor.impact > 0 ? '+' : '';
-            result += `    • ${factor.name}: ${impactSign}${factor.impact} - ${factor.description}\n`;
-        });
-        result += '\n';
-    }
-    if (output.recommendations && output.recommendations.length > 0) {
-        result += `  Recommendations:\n`;
-        output.recommendations.forEach((rec, i) => {
-            const priorityIcon = rec.priority === 'high' ? '🔴' :
-                rec.priority === 'medium' ? '🟡' : '🔵';
-            result += `    ${i + 1}. ${priorityIcon} ${rec.action}\n`;
-            result += `       Impact: +${rec.estimatedImpact} points\n\n`;
-        });
-    }
-    return result;
+  let result = `  Score: ${output.score}/100\n\n`;
+  if (output.factors && output.factors.length > 0) {
+    result += `  Factors:\n`;
+    output.factors.forEach((factor) => {
+      const impactSign = factor.impact > 0 ? '+' : '';
+      result += `    • ${factor.name}: ${impactSign}${factor.impact} - ${factor.description}\n`;
+    });
+    result += '\n';
+  }
+  if (output.recommendations && output.recommendations.length > 0) {
+    result += `  Recommendations:\n`;
+    output.recommendations.forEach((rec, i) => {
+      const priorityIcon =
+        rec.priority === 'high'
+          ? '🔴'
+          : rec.priority === 'medium'
+            ? '🟡'
+            : '🔵';
+      result += `    ${i + 1}. ${priorityIcon} ${rec.action}\n`;
+      result += `       Impact: +${rec.estimatedImpact} points\n\n`;
+    });
+  }
+  return result;
 }
-//# sourceMappingURL=scoring.js.map
+//# sourceMappingURL=scoring.js.map

package/dist/types/language.d.ts

@@ -8,13 +8,13 @@
  * Supported programming languages
  */
 export declare enum Language {
-    TypeScript = "typescript",
-    JavaScript = "javascript",
-    Python = "python",
-    Java = "java",
-    Go = "go",
-    Rust = "rust",
-    CSharp = "csharp"
+  TypeScript = 'typescript',
+  JavaScript = 'javascript',
+  Python = 'python',
+  Java = 'java',
+  Go = 'go',
+  Rust = 'rust',
+  CSharp = 'csharp',
 }
 /**
  * File extensions mapped to languages
@@ -24,138 +24,149 @@ export declare const LANGUAGE_EXTENSIONS: Record<string, Language>;
  * Location information in source code
  */
 export interface SourceLocation {
-    line: number;
-    column: number;
+  line: number;
+  column: number;
 }
 export interface SourceRange {
-    start: SourceLocation;
-    end: SourceLocation;
+  start: SourceLocation;
+  end: SourceLocation;
 }
 /**
  * Common AST node type (language-agnostic)
  */
 export interface CommonASTNode {
-    type: string;
-    loc?: SourceRange;
-    raw?: any;
+  type: string;
+  loc?: SourceRange;
+  raw?: any;
 }
 /**
  * Export information (function, class, variable, etc.)
  */
 export interface ExportInfo {
-    name: string;
-    type: 'function' | 'class' | 'const' | 'type' | 'interface' | 'default' | 'variable';
-    loc?: SourceRange;
-    /** Imports used within this export */
-    imports?: string[];
-    /** Dependencies on other exports in same file */
-    dependencies?: string[];
-    /** TypeScript types referenced */
-    typeReferences?: string[];
-    /** For methods: parent class name */
-    parentClass?: string;
-    /** For functions/methods: parameters */
-    parameters?: string[];
-    /** Visibility (public, private, protected) */
-    visibility?: 'public' | 'private' | 'protected';
+  name: string;
+  type:
+    | 'function'
+    | 'class'
+    | 'const'
+    | 'type'
+    | 'interface'
+    | 'default'
+    | 'variable';
+  loc?: SourceRange;
+  /** Imports used within this export */
+  imports?: string[];
+  /** Dependencies on other exports in same file */
+  dependencies?: string[];
+  /** TypeScript types referenced */
+  typeReferences?: string[];
+  /** For methods: parent class name */
+  parentClass?: string;
+  /** For functions/methods: parameters */
+  parameters?: string[];
+  /** Visibility (public, private, protected) */
+  visibility?: 'public' | 'private' | 'protected';
 }
 /**
  * Import information
  */
 export interface ImportInfo {
-    /** Module being imported from */
-    source: string;
-    /** What's being imported */
-    specifiers: string[];
-    /** Is this a type-only import (TypeScript) */
-    isTypeOnly?: boolean;
-    /** Location in source */
-    loc?: SourceRange;
+  /** Module being imported from */
+  source: string;
+  /** What's being imported */
+  specifiers: string[];
+  /** Is this a type-only import (TypeScript) */
+  isTypeOnly?: boolean;
+  /** Location in source */
+  loc?: SourceRange;
 }
 /**
  * Parse result containing exports and imports
  */
 export interface ParseResult {
-    exports: ExportInfo[];
-    imports: ImportInfo[];
-    /** Language of the parsed file */
-    language: Language;
-    /** Any parse warnings (non-fatal) */
-    warnings?: string[];
+  exports: ExportInfo[];
+  imports: ImportInfo[];
+  /** Language of the parsed file */
+  language: Language;
+  /** Any parse warnings (non-fatal) */
+  warnings?: string[];
 }
 /**
  * Naming convention rules per language
  */
 export interface NamingConvention {
-    /** Allowed variable naming patterns */
-    variablePattern: RegExp;
-    /** Allowed function naming patterns */
-    functionPattern: RegExp;
-    /** Allowed class naming patterns */
-    classPattern: RegExp;
-    /** Allowed constant naming patterns */
-    constantPattern: RegExp;
-    /** Language-specific exceptions (e.g., __init__ in Python) */
-    exceptions?: string[];
+  /** Allowed variable naming patterns */
+  variablePattern: RegExp;
+  /** Allowed function naming patterns */
+  functionPattern: RegExp;
+  /** Allowed class naming patterns */
+  classPattern: RegExp;
+  /** Allowed constant naming patterns */
+  constantPattern: RegExp;
+  /** Language-specific exceptions (e.g., __init__ in Python) */
+  exceptions?: string[];
 }
 /**
  * Language-specific configuration
  */
 export interface LanguageConfig {
-    language: Language;
-    /** File extensions for this language */
-    extensions: string[];
-    /** Naming conventions */
-    namingConventions: NamingConvention;
-    /** Common abbreviations allowed */
-    allowedAbbreviations?: string[];
-    /** Language-specific keywords to ignore */
-    keywords?: string[];
+  language: Language;
+  /** File extensions for this language */
+  extensions: string[];
+  /** Naming conventions */
+  namingConventions: NamingConvention;
+  /** Common abbreviations allowed */
+  allowedAbbreviations?: string[];
+  /** Language-specific keywords to ignore */
+  keywords?: string[];
 }
 /**
  * Abstract interface for language parsers
  * Each language implementation should implement this interface
  */
 export interface LanguageParser {
-    /** Language this parser handles */
-    readonly language: Language;
-    /** File extensions this parser supports */
-    readonly extensions: string[];
-    /**
-     * Parse source code and extract structure
-     * @param code - Source code to parse
-     * @param filePath - Path to the file (for context)
-     * @returns Parse result with exports and imports
-     * @throws ParseError if code has syntax errors
-     */
-    parse(code: string, filePath: string): ParseResult;
-    /**
-     * Get naming conventions for this language
-     */
-    getNamingConventions(): NamingConvention;
-    /**
-     * Check if this parser can handle a file
-     * @param filePath - File path to check
-     */
-    canHandle(filePath: string): boolean;
+  /** Language this parser handles */
+  readonly language: Language;
+  /** File extensions this parser supports */
+  readonly extensions: string[];
+  /**
+   * Parse source code and extract structure
+   * @param code - Source code to parse
+   * @param filePath - Path to the file (for context)
+   * @returns Parse result with exports and imports
+   * @throws ParseError if code has syntax errors
+   */
+  parse(code: string, filePath: string): ParseResult;
+  /**
+   * Get naming conventions for this language
+   */
+  getNamingConventions(): NamingConvention;
+  /**
+   * Check if this parser can handle a file
+   * @param filePath - File path to check
+   */
+  canHandle(filePath: string): boolean;
 }
 /**
  * Parser error with location information
  */
 export declare class ParseError extends Error {
-    readonly filePath: string;
-    readonly loc?: SourceLocation | undefined;
-    constructor(message: string, filePath: string, loc?: SourceLocation | undefined);
+  readonly filePath: string;
+  readonly loc?: SourceLocation | undefined;
+  constructor(
+    message: string,
+    filePath: string,
+    loc?: SourceLocation | undefined
+  );
 }
 /**
  * Statistics about parsed code
  */
 export interface ParseStatistics {
-    language: Language;
-    filesAnalyzed: number;
-    totalExports: number;
-    totalImports: number;
-    parseErrors: number;
-    warnings: number;
+  language: Language;
+  filesAnalyzed: number;
+  totalExports: number;
+  totalImports: number;
+  parseErrors: number;
+  warnings: number;
 }
-//# sourceMappingURL=language.d.ts.map
+//# sourceMappingURL=language.d.ts.map

package/dist/types/language.js

@@ -9,37 +9,37 @@
  */
 export var Language;
 (function (Language) {
-    Language["TypeScript"] = "typescript";
-    Language["JavaScript"] = "javascript";
-    Language["Python"] = "python";
-    Language["Java"] = "java";
-    Language["Go"] = "go";
-    Language["Rust"] = "rust";
-    Language["CSharp"] = "csharp";
+  Language['TypeScript'] = 'typescript';
+  Language['JavaScript'] = 'javascript';
+  Language['Python'] = 'python';
+  Language['Java'] = 'java';
+  Language['Go'] = 'go';
+  Language['Rust'] = 'rust';
+  Language['CSharp'] = 'csharp';
 })(Language || (Language = {}));
 /**
  * File extensions mapped to languages
  */
 export const LANGUAGE_EXTENSIONS = {
-    '.ts': Language.TypeScript,
-    '.tsx': Language.TypeScript,
-    '.js': Language.JavaScript,
-    '.jsx': Language.JavaScript,
-    '.py': Language.Python,
-    '.java': Language.Java,
-    '.go': Language.Go,
-    '.rs': Language.Rust,
-    '.cs': Language.CSharp,
+  '.ts': Language.TypeScript,
+  '.tsx': Language.TypeScript,
+  '.js': Language.JavaScript,
+  '.jsx': Language.JavaScript,
+  '.py': Language.Python,
+  '.java': Language.Java,
+  '.go': Language.Go,
+  '.rs': Language.Rust,
+  '.cs': Language.CSharp,
 };
 /**
  * Parser error with location information
  */
 export class ParseError extends Error {
-    constructor(message, filePath, loc) {
-        super(message);
-        this.filePath = filePath;
-        this.loc = loc;
-        this.name = 'ParseError';
-    }
+  constructor(message, filePath, loc) {
+    super(message);
+    this.filePath = filePath;
+    this.loc = loc;
+    this.name = 'ParseError';
+  }
 }
-//# sourceMappingURL=language.js.map
+//# sourceMappingURL=language.js.map