@aiready/core 0.21.18 → 0.22.0

package/dist/index.mjs

@@ -18,6 +18,8 @@ import {
   ModelTier,
   ModelTierSchema,
   ParseError,
+  ReadinessRating,
+  RecommendationPriority,
   SIZE_ADJUSTED_THRESHOLDS,
   Severity,
   SeveritySchema,
@@ -39,7 +41,7 @@ import {
   getToolWeight,
   normalizeToolName,
   parseWeightString
-} from "./chunk-COHIBX3Q.mjs";
+} from "./chunk-SWTDBVYJ.mjs";
 
 // src/types/contract.ts
 function validateSpokeOutput(toolName, output) {
@@ -100,51 +102,61 @@ function validateWithSchema(schema, data) {
 }
 
 // src/registry.ts
-var ToolRegistry = class {
-  static getProviders() {
-    const g = globalThis;
-    if (!g.__AIRE_TOOL_REGISTRY__) {
-      g.__AIRE_TOOL_REGISTRY__ = /* @__PURE__ */ new Map();
-    }
-    return g.__AIRE_TOOL_REGISTRY__;
+var ToolRegistry = class _ToolRegistry {
+  /**
+   * Create a new ToolRegistry instance
+   *
+   * @param id Optional identifier for the registry (e.g. for debugging)
+   */
+  constructor(id = "default") {
+    this.providers = /* @__PURE__ */ new Map();
+    this.id = `registry-${id}-${Math.random().toString(36).substring(2, 9)}`;
   }
   /**
    * Register a new tool provider.
+   *
+   * @param provider The tool provider to register
    */
-  static register(provider) {
-    console.log(
-      `[ToolRegistry#${this.instanceId}] Registering tool: ${provider.id} (${provider.alias.join(", ")})`
-    );
-    this.getProviders().set(provider.id, provider);
+  register(provider) {
+    this.providers.set(provider.id, provider);
   }
   /**
    * Get a provider by its canonical ID.
+   *
+   * @param id The tool ID
+   * @returns The provider if found
    */
-  static get(id) {
-    return this.getProviders().get(id);
+  get(id) {
+    return this.providers.get(id);
   }
   /**
    * Get a provider by name or alias.
+   *
+   * @param nameOrAlias The tool name or alias string
+   * @returns The provider if found
    */
-  static find(nameOrAlias) {
-    const providers = this.getProviders();
-    const exact = providers.get(nameOrAlias);
+  find(nameOrAlias) {
+    const exact = this.providers.get(nameOrAlias);
     if (exact) return exact;
-    for (const p of providers.values()) {
+    for (const p of this.providers.values()) {
       if (p.alias.includes(nameOrAlias)) return p;
     }
     return void 0;
   }
   /**
    * Get all registered tool providers.
+   *
+   * @returns Array of all registered tool providers
    */
-  static getAll() {
-    return Array.from(this.getProviders().values());
+  getAll() {
+    return Array.from(this.providers.values());
   }
   /**
    * Get all available tool IDs from the ToolName enum.
+   *
+   * @returns Array of valid ToolName identifiers
    */
-  static getAvailableIds() {
+  getAvailableIds() {
     return Object.values(ToolName).filter(
       (v) => typeof v === "string"
     );
@@ -152,11 +164,54 @@ var ToolRegistry = class {
   /**
    * Clear the registry (primarily for testing).
    */
+  clear() {
+    this.providers.clear();
+  }
+  // --- Static Compatibility Layer ---
+  static getGlobalRegistry() {
+    const g = globalThis;
+    if (!g.__AIRE_TOOL_REGISTRY_INSTANCE__) {
+      g.__AIRE_TOOL_REGISTRY_INSTANCE__ = new _ToolRegistry("global");
+    }
+    return g.__AIRE_TOOL_REGISTRY_INSTANCE__;
+  }
+  /**
+   * Static register (Singleton compatibility)
+   */
+  static register(provider) {
+    this.getGlobalRegistry().register(provider);
+  }
+  /**
+   * Static get (Singleton compatibility)
+   */
+  static get(id) {
+    return this.getGlobalRegistry().get(id);
+  }
+  /**
+   * Static find (Singleton compatibility)
+   */
+  static find(nameOrAlias) {
+    return this.getGlobalRegistry().find(nameOrAlias);
+  }
+  /**
+   * Static getAll (Singleton compatibility)
+   */
+  static getAll() {
+    return this.getGlobalRegistry().getAll();
+  }
+  /**
+   * Static getAvailableIds (Singleton compatibility)
+   */
+  static getAvailableIds() {
+    return this.getGlobalRegistry().getAvailableIds();
+  }
+  /**
+   * Static clear (Singleton compatibility)
+   */
   static clear() {
-    this.getProviders().clear();
+    this.getGlobalRegistry().clear();
   }
 };
-ToolRegistry.instanceId = globalThis.Math.random();
 
 // src/utils/file-scanner.ts
 import { glob } from "glob";
@@ -268,7 +323,8 @@ async function scanFiles(options) {
   });
   const gitignoreFiles = await glob("**/.gitignore", {
     cwd: rootDir,
-    ignore: finalExclude,
+    ignore: (exclude || []).concat(["**/node_modules/**", "**/.git/**"]),
+    // Minimal ignore for gitignore discovery
     absolute: true
   });
   if (gitignoreFiles.length > 0) {
@@ -335,7 +391,7 @@ async function scanEntries(options) {
   });
   const gitignoreFiles = await glob("**/.gitignore", {
     cwd: rootDir,
-    ignore: finalExclude,
+    ignore: (exclude || []).concat(["**/node_modules/**", "**/.git/**"]),
     absolute: true
   });
   if (gitignoreFiles.length > 0) {
@@ -359,8 +415,9 @@ async function scanEntries(options) {
       }
     }
     const filteredDirs = dirs.filter((d) => {
-      const rel = relative(rootDir || ".", d).replace(/\\/g, "/").replace(/\/$/, "");
+      let rel = relative(rootDir || ".", d).replace(/\\/g, "/");
       if (rel === "") return true;
+      if (!rel.endsWith("/")) rel += "/";
       return !ig.ignores(rel);
     });
     return { files, dirs: filteredDirs };
@@ -425,7 +482,8 @@ function getElapsedTime(startTime) {
   return ((Date.now() - startTime) / 1e3).toFixed(2);
 }
 function getScoreBar(val) {
-  return "\u2588".repeat(Math.round(val / 10)).padEnd(10, "\u2591");
+  const clamped = Math.max(0, Math.min(100, val));
+  return "\u2588".repeat(Math.round(clamped / 10)).padEnd(10, "\u2591");
 }
 function getSafetyIcon(rating) {
   switch (rating) {
@@ -686,7 +744,7 @@ var TypeScriptParser = class {
   extractFromDeclaration(declaration, importedNames, code, parentNode) {
     const exports = [];
     const metadata = this.analyzeMetadata(parentNode || declaration, code);
-    if (declaration.type === "FunctionDeclaration" && declaration.id) {
+    if ((declaration.type === "FunctionDeclaration" || declaration.type === "TSDeclareFunction") && declaration.id) {
       exports.push({
         name: declaration.id.name,
         type: "function",
@@ -714,11 +772,21 @@ var TypeScriptParser = class {
       const body = declaration.body.body;
       const methods = body.filter((m) => m.type === "MethodDefinition");
       const properties = body.filter((m) => m.type === "PropertyDefinition");
+      const constructor = methods.find(
+        (m) => m.kind === "constructor"
+      );
+      const parameters = constructor ? constructor.value.params.map((p) => {
+        if (p.type === "Identifier") return p.name;
+        if (p.type === "TSParameterProperty" && p.parameter.type === "Identifier")
+          return p.parameter.name;
+        return "unknown";
+      }) : [];
       exports.push({
         name: declaration.id.name,
         type: "class",
         methodCount: methods.length,
         propertyCount: properties.length,
+        parameters,
         loc: declaration.loc ? {
           start: {
             line: declaration.loc.start.line,
@@ -2165,6 +2233,9 @@ var GoParser = class {
 
 // src/parsers/parser-factory.ts
 var ParserFactory = class _ParserFactory {
+  /**
+   * Create a new ParserFactory instance
+   */
   constructor() {
     this.parsers = /* @__PURE__ */ new Map();
     this.extensionMap = new Map(
@@ -2177,7 +2248,9 @@ var ParserFactory = class _ParserFactory {
     this.registerParser(new GoParser());
   }
   /**
-   * Get singleton instance
+   * Get the global singleton instance
+   *
+   * @returns The singleton ParserFactory instance
    */
   static getInstance() {
     if (!_ParserFactory.instance) {
@@ -2628,15 +2701,17 @@ var DEFAULT_COST_CONFIG = {
   daysPerMonth: 30
 };
 function calculateMonthlyCost(tokenWaste, config = {}) {
+  const multiplier = tokenWaste > 5e4 ? 5 : tokenWaste > 1e4 ? 3.5 : 2.5;
   const budget = calculateTokenBudget({
-    totalContextTokens: tokenWaste * 2.5,
+    totalContextTokens: tokenWaste * multiplier,
     wastedTokens: {
       duplication: tokenWaste * 0.7,
       fragmentation: tokenWaste * 0.3,
-      chattiness: 0
+      chattiness: 0.1 * tokenWaste
+      // Added baseline chattiness
     }
   });
-  const preset = getModelPreset("claude-4.6");
+  const preset = getModelPreset("claude-3.5-sonnet");
   return estimateCostFromBudget(budget, preset, config);
 }
 function calculateTokenBudget(params) {
@@ -3118,7 +3193,7 @@ function calculatePatternEntropy(files) {
   }
   const dirGroups = /* @__PURE__ */ new Map();
   for (const file of files) {
-    const parts = file.path.split("/").slice(0, 4).join("/") || "root";
+    const parts = file.path.split("/").slice(0, -1).join("/") || "root";
     dirGroups.set(parts, (dirGroups.get(parts) || 0) + 1);
   }
   const counts = Array.from(dirGroups.values());
@@ -3225,6 +3300,8 @@ function calculateAiSignalClarity(params) {
     deepCallbacks,
     ambiguousNames,
     undocumentedExports,
+    largeFiles = 0,
+    // Default to 0 to prevent NaN
     totalSymbols,
     totalExports
   } = params;
@@ -3241,28 +3318,35 @@ function calculateAiSignalClarity(params) {
   const overloadSignal = {
     name: "Symbol Overloading",
     count: overloadedSymbols,
-    riskContribution: Math.round(Math.min(1, overloadRatio) * 100 * 0.25),
+    riskContribution: Math.round(Math.min(1, overloadRatio) * 100 * 0.2),
     description: `${overloadedSymbols} overloaded symbols \u2014 AI picks wrong signature`
   };
+  const largeFileSignal = {
+    name: "Large Files",
+    count: largeFiles,
+    riskContribution: Math.round(Math.min(5, largeFiles) * 5),
+    // up to 25 points
+    description: `${largeFiles} large files \u2014 pushing AI context limits`
+  };
   const magicRatio = magicLiterals / Math.max(1, totalSymbols * 2);
   const magicSignal = {
     name: "Magic Literals",
     count: magicLiterals,
-    riskContribution: Math.round(Math.min(1, magicRatio) * 100 * 0.2),
+    riskContribution: Math.round(Math.min(1, magicRatio) * 100 * 0.15),
     description: `${magicLiterals} unnamed constants \u2014 AI invents wrong values`
   };
   const trapRatio = booleanTraps / Math.max(1, totalSymbols);
   const trapSignal = {
     name: "Boolean Traps",
     count: booleanTraps,
-    riskContribution: Math.round(Math.min(1, trapRatio) * 100 * 0.2),
+    riskContribution: Math.round(Math.min(1, trapRatio) * 100 * 0.15),
     description: `${booleanTraps} boolean trap parameters \u2014 AI inverts intent`
   };
   const sideEffectRatio = implicitSideEffects / Math.max(1, totalExports);
   const sideEffectSignal = {
     name: "Implicit Side Effects",
     count: implicitSideEffects,
-    riskContribution: Math.round(Math.min(1, sideEffectRatio) * 100 * 0.15),
+    riskContribution: Math.round(Math.min(1, sideEffectRatio) * 100 * 0.1),
     description: `${implicitSideEffects} functions with implicit side effects \u2014 AI misses contracts`
   };
   const callbackRatio = deepCallbacks / Math.max(1, totalSymbols * 0.1);
@@ -3276,18 +3360,19 @@ function calculateAiSignalClarity(params) {
   const ambiguousSignal = {
     name: "Ambiguous Names",
     count: ambiguousNames,
-    riskContribution: Math.round(Math.min(1, ambiguousRatio) * 100 * 0.1),
+    riskContribution: Math.round(Math.min(1, ambiguousRatio) * 100 * 0.05),
     description: `${ambiguousNames} non-descriptive identifiers \u2014 AI guesses wrong intent`
   };
   const undocRatio = undocumentedExports / Math.max(1, totalExports);
   const undocSignal = {
     name: "Undocumented Exports",
     count: undocumentedExports,
-    riskContribution: Math.round(Math.min(1, undocRatio) * 100 * 0.1),
+    riskContribution: Math.round(Math.min(1, undocRatio) * 100 * 0.05),
     description: `${undocumentedExports} public functions without docs \u2014 AI fabricates behavior`
   };
   const signals = [
     overloadSignal,
+    largeFileSignal,
     magicSignal,
     trapSignal,
     sideEffectSignal,
@@ -3310,6 +3395,10 @@ function calculateAiSignalClarity(params) {
   );
   const topRisk = topSignal.riskContribution > 0 ? topSignal.description : "No significant issues detected";
   const recommendations = [];
+  if (largeFileSignal.riskContribution > 5)
+    recommendations.push(
+      `Split ${largeFiles} large files (> 500 lines) into smaller, single-responsibility modules`
+    );
   if (overloadSignal.riskContribution > 5)
     recommendations.push(
       `Rename ${overloadedSymbols} overloaded symbols to unique, intent-revealing names`
@@ -3945,6 +4034,46 @@ function getRepoMetadata(directory) {
   }
   return metadata;
 }
+
+// src/utils/github-utils.ts
+function emitAnnotation(params) {
+  const { level, file, line, col, title, message } = params;
+  const parts = [];
+  if (file) parts.push(`file=${file}`);
+  if (line) parts.push(`line=${line}`);
+  if (col) parts.push(`col=${col}`);
+  if (title) parts.push(`title=${title}`);
+  const metadata = parts.length > 0 ? ` ${parts.join(",")}` : "";
+  console.log(`::${level}${metadata}::${message.replace(/\n/g, "%0A")}`);
+}
+function severityToAnnotationLevel(severity) {
+  switch (severity.toLowerCase()) {
+    case "critical":
+    case "high-risk":
+    case "blind-risk":
+      return "error";
+    case "major":
+    case "moderate-risk":
+      return "warning";
+    case "minor":
+    case "info":
+    case "safe":
+    default:
+      return "notice";
+  }
+}
+function emitIssuesAsAnnotations(issues) {
+  issues.forEach((issue) => {
+    emitAnnotation({
+      level: severityToAnnotationLevel(issue.severity || "info"),
+      file: issue.file || issue.fileName || "",
+      line: issue.line || issue.location?.start?.line,
+      col: issue.column || issue.location?.start?.column,
+      title: `${issue.tool || "AIReady"}: ${issue.type || "Issue"}`,
+      message: issue.message || issue.description || "No description provided"
+    });
+  });
+}
 export {
   AnalysisResultSchema,
   AnalysisStatus,
@@ -3973,6 +4102,8 @@ export {
   ParseError,
   ParserFactory,
   PythonParser,
+  ReadinessRating,
+  RecommendationPriority,
   SEVERITY_TIME_ESTIMATES,
   SIZE_ADJUSTED_THRESHOLDS,
   Severity,
@@ -4009,6 +4140,8 @@ export {
   calculateTestabilityIndex,
   calculateTokenBudget,
   clearHistory,
+  emitAnnotation,
+  emitIssuesAsAnnotations,
   emitProgress,
   estimateCostFromBudget,
   estimateTokens,
@@ -4062,6 +4195,7 @@ export {
   scanEntries,
   scanFiles,
   setupParser,
+  severityToAnnotationLevel,
   validateSpokeOutput,
   validateWithSchema
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/core",
-  "version": "0.21.18",
+  "version": "0.22.0",
   "description": "Shared utilities for AIReady analysis tools",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",