@aiready/core 0.24.23 → 0.24.26

package/dist/index.js

@@ -96,7 +96,10 @@ var init_typescript_parser = __esm({
             range: true,
             tokens: true,
             comment: true,
-            jsx: filePath.endsWith("x")
+            jsx: filePath.endsWith("x"),
+            ecmaVersion: "latest"
+            // Support for latest TypeScript features like Decorators and Explicit Resource Management
+            // are enabled by default in latest typescript-estree when ecmaVersion is 'latest'.
           });
         } catch (error) {
           const err = error;
@@ -114,7 +117,10 @@ var init_typescript_parser = __esm({
             range: true,
             tokens: true,
             comment: true,
-            jsx: filePath.endsWith("x")
+            jsx: filePath.endsWith("x"),
+            ecmaVersion: "latest"
+            // Support for latest TypeScript features like Decorators and Explicit Resource Management
+            // are enabled by default in latest typescript-estree when ecmaVersion is 'latest'.
           });
           const imports = this.extractImports(ast);
           const exports2 = this.extractExports(ast, code, filePath);
@@ -266,7 +272,7 @@ var init_typescript_parser = __esm({
         let isPrimitive = false;
         let isTyped = false;
         if (initializer) {
-          if (initializer.type === "Literal" || initializer.type === "TemplateLiteral" && initializer.expressions.length === 0) {
+          if (initializer.type === "Literal" || initializer.type === "BigIntLiteral" || initializer.type === "TemplateLiteral" && initializer.expressions.length === 0) {
             isPrimitive = true;
           }
         }
@@ -365,7 +371,8 @@ var init_typescript_parser = __esm({
               body,
               (_, v) => typeof v === "bigint" ? v.toString() : v
             );
-            if (bodyContent.includes('"name":"console"') || bodyContent.includes('"name":"process"') || bodyContent.includes('"name":"fs"') || bodyContent.includes('"name":"global"') || bodyContent.includes('"name":"window"') || bodyContent.includes('"name":"fetch"') || bodyContent.includes('"name":"axios"')) {
+            if (bodyContent.includes('"name":"console"') || bodyContent.includes('"name":"process"') || bodyContent.includes('"name":"fs"') || bodyContent.includes('"name":"global"') || bodyContent.includes('"name":"window"') || bodyContent.includes('"name":"fetch"') || bodyContent.includes('"name":"axios"') || bodyContent.includes('"type":"UsingDeclaration"') || // Explicit Resource Management
+            bodyContent.includes('"type":"AwaitExpression"')) {
               return false;
             }
             return true;
@@ -501,6 +508,25 @@ var init_metadata_utils = __esm({
   }
 });
 
+// src/utils/path-utils.ts
+function getDirname(importMetaUrl) {
+  if (importMetaUrl) {
+    return (0, import_path4.dirname)((0, import_url.fileURLToPath)(importMetaUrl));
+  }
+  if (typeof __dirname !== "undefined") {
+    return __dirname;
+  }
+  throw new Error("getDirname: importMetaUrl is required in ESM environments");
+}
+var import_path4, import_url;
+var init_path_utils = __esm({
+  "src/utils/path-utils.ts"() {
+    "use strict";
+    import_path4 = require("path");
+    import_url = require("url");
+  }
+});
+
 // src/parsers/tree-sitter-utils.ts
 async function initTreeSitter() {
   if (isTreeSitterInitialized) return;
@@ -554,18 +580,18 @@ function getWasmPath(language) {
   const wasmFileName = language === "web-tree-sitter" ? "web-tree-sitter.wasm" : `tree-sitter-${language}.wasm`;
   const immediatePaths = [
     path.join(process.cwd(), wasmFileName),
-    path.join(__dirname, wasmFileName),
-    path.join(__dirname, "assets", wasmFileName)
+    path.join(__dirname2, wasmFileName),
+    path.join(__dirname2, "assets", wasmFileName)
   ];
   for (const p of immediatePaths) {
     if (fs.existsSync(p)) return p;
   }
-  const pnpmPath = findInPnpmStore(__dirname, wasmFileName);
+  const pnpmPath = findInPnpmStore(__dirname2, wasmFileName);
   if (pnpmPath) return pnpmPath;
   const pnpmPathCwd = findInPnpmStore(process.cwd(), wasmFileName);
   if (pnpmPathCwd) return pnpmPathCwd;
   console.warn(
-    `[Parser] WASM file for ${language} not found. CWD: ${process.cwd()}, DIR: ${__dirname}`
+    `[Parser] WASM file for ${language} not found. CWD: ${process.cwd()}, DIR: ${__dirname2}`
   );
   return null;
 }
@@ -584,24 +610,23 @@ async function setupParser(language) {
     return null;
   }
 }
-var Parser, path, fs, import_url, import_meta, getDirname, __dirname, isTreeSitterInitialized;
+var Parser, path, fs, import_meta, getDirname2, __dirname2, isTreeSitterInitialized;
 var init_tree_sitter_utils = __esm({
   "src/parsers/tree-sitter-utils.ts"() {
     "use strict";
     Parser = __toESM(require("web-tree-sitter"));
     path = __toESM(require("path"));
     fs = __toESM(require("fs"));
-    import_url = require("url");
+    init_path_utils();
     import_meta = {};
-    getDirname = () => {
+    getDirname2 = () => {
       try {
-        if (typeof __dirname !== "undefined") return __dirname;
-        return path.dirname((0, import_url.fileURLToPath)(import_meta.url));
+        return getDirname(import_meta.url);
       } catch {
         return process.cwd();
       }
     };
-    __dirname = getDirname();
+    __dirname2 = getDirname2();
     isTreeSitterInitialized = false;
   }
 });
@@ -2034,6 +2059,7 @@ __export(index_exports, {
   COMMON_FINE_TUNING_OPTIONS: () => COMMON_FINE_TUNING_OPTIONS,
   CONTEXT_TIER_THRESHOLDS: () => CONTEXT_TIER_THRESHOLDS,
   CSharpParser: () => CSharpParser,
+  DEFAULT_AUTO_EXCLUDE_PATTERNS: () => DEFAULT_AUTO_EXCLUDE_PATTERNS,
   DEFAULT_COST_CONFIG: () => DEFAULT_COST_CONFIG,
   DEFAULT_EXCLUDE: () => DEFAULT_EXCLUDE,
   DEFAULT_TOOL_WEIGHTS: () => DEFAULT_TOOL_WEIGHTS,
@@ -2042,6 +2068,8 @@ __export(index_exports, {
   FRIENDLY_TOOL_NAMES: () => FRIENDLY_TOOL_NAMES,
   GLOBAL_INFRA_OPTIONS: () => GLOBAL_INFRA_OPTIONS,
   GLOBAL_SCAN_OPTIONS: () => GLOBAL_SCAN_OPTIONS,
+  GitHubIssueResolverAgent: () => GitHubIssueResolverAgent,
+  GitHubService: () => GitHubService,
   GoParser: () => GoParser,
   IssueSchema: () => IssueSchema,
   IssueType: () => IssueType,
@@ -2146,6 +2174,8 @@ __export(index_exports, {
   generateStatCards: () => generateStatCards,
   generateTable: () => generateTable,
   generateValueChain: () => generateValueChain,
+  getChangedFiles: () => getChangedFiles,
+  getDirname: () => getDirname,
   getElapsedTime: () => getElapsedTime,
   getErrorMessage: () => getErrorMessage,
   getFileCommitTimestamps: () => getFileCommitTimestamps,
@@ -2214,12 +2244,14 @@ __export(index_exports, {
   resolveOutputPath: () => resolveOutputPath,
   runBatchAnalysis: () => runBatchAnalysis,
   runStandardCliAction: () => runStandardCliAction,
+  safeJsonStringify: () => safeJsonStringify,
   saveScoreEntry: () => saveScoreEntry,
   scanEntries: () => scanEntries,
   scanFiles: () => scanFiles,
   setupParser: () => setupParser,
   severityToAnnotationLevel: () => severityToAnnotationLevel,
   toErrorMessage: () => toErrorMessage,
+  validateConfig: () => validateConfig,
   validateSpokeOutput: () => validateSpokeOutput,
   validateWithSchema: () => validateWithSchema,
   withErrorHandling: () => withErrorHandling,
@@ -2325,6 +2357,7 @@ var import_zod3 = require("zod");
 var IssueSchema = import_zod3.z.object({
   type: IssueTypeSchema,
   severity: SeveritySchema,
+  category: import_zod3.z.string().optional(),
   message: import_zod3.z.string(),
   location: LocationSchema,
   suggestion: import_zod3.z.string().optional()
@@ -2365,6 +2398,7 @@ var SpokeSummarySchema = import_zod5.z.object({
   totalIssues: import_zod5.z.number().optional(),
   criticalIssues: import_zod5.z.number().optional(),
   majorIssues: import_zod5.z.number().optional(),
+  minorIssues: import_zod5.z.number().optional(),
   score: import_zod5.z.number().optional()
 }).catchall(import_zod5.z.any());
 var SpokeOutputSchema = import_zod5.z.object({
@@ -2383,6 +2417,7 @@ var UnifiedReportSchema = import_zod5.z.object({
     totalIssues: import_zod5.z.number(),
     criticalIssues: import_zod5.z.number(),
     majorIssues: import_zod5.z.number(),
+    minorIssues: import_zod5.z.number(),
     businessImpact: import_zod5.z.object({
       estimatedMonthlyWaste: import_zod5.z.number().optional(),
       potentialSavings: import_zod5.z.number().optional(),
@@ -2405,9 +2440,24 @@ var UnifiedReportSchema = import_zod5.z.object({
 
 // src/types/schemas/config.ts
 var import_zod6 = require("zod");
+var AutoExcludeSchema = import_zod6.z.object({
+  /** Enable automatic detection of test files */
+  tests: import_zod6.z.boolean().optional(),
+  /** Enable automatic detection of mock files */
+  mocks: import_zod6.z.boolean().optional(),
+  /** Enable automatic detection of barrel/re-export files */
+  barrels: import_zod6.z.boolean().optional(),
+  /** Enable automatic detection of generated files */
+  generated: import_zod6.z.boolean().optional()
+}).optional();
+var TieredExcludeSchema = import_zod6.z.record(import_zod6.z.string(), import_zod6.z.array(import_zod6.z.string()));
 var AIReadyConfigSchema = import_zod6.z.object({
-  /** Files or directories to exclude from scan */
-  exclude: import_zod6.z.array(import_zod6.z.string()).optional(),
+  /** Extend from another config file (relative path) */
+  extends: import_zod6.z.string().optional(),
+  /** Files or directories to exclude from scan (flat array or tiered) */
+  exclude: import_zod6.z.union([import_zod6.z.array(import_zod6.z.string()), TieredExcludeSchema]).optional(),
+  /** Auto-exclusion settings for common patterns */
+  autoExclude: AutoExcludeSchema,
   /** Fail CI/CD if score below threshold (0-100) */
   threshold: import_zod6.z.number().optional(),
   /** Fail on issues: critical, major, any */
@@ -2434,7 +2484,15 @@ var AIReadyConfigSchema = import_zod6.z.object({
     compareBaseline: import_zod6.z.string().optional()
   }).optional(),
   /** Tool-specific configuration overrides (Strictly ToolName -> Config) */
-  tools: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.any()).optional(),
+  tools: import_zod6.z.record(
+    import_zod6.z.string(),
+    import_zod6.z.object({
+      /** Whether to enable this tool */
+      enabled: import_zod6.z.boolean().optional(),
+      /** Severity overrides for specific categories */
+      severityOverrides: import_zod6.z.record(import_zod6.z.string(), SeveritySchema).optional()
+    }).catchall(import_zod6.z.any())
+  ).optional(),
   /** Scoring profile and weights */
   scoring: import_zod6.z.object({
     /** Name of the scoring profile (e.g. "strict", "balanced") */
@@ -2516,7 +2574,8 @@ var GLOBAL_INFRA_OPTIONS = [
   "include",
   "exclude",
   "tools",
-  "scoring"
+  "scoring",
+  "changedFilesOnly"
 ];
 var GLOBAL_SCAN_OPTIONS = [
   "rootDir",
@@ -2527,7 +2586,7 @@ var GLOBAL_SCAN_OPTIONS = [
   "output",
   "format",
   "parallel",
-  "showBreakdown"
+  "changedFilesOnly"
 ];
 var COMMON_FINE_TUNING_OPTIONS = [
   "maxDepth",
@@ -2795,6 +2854,106 @@ var import_promises = require("fs/promises");
 var import_fs = require("fs");
 var import_path = require("path");
 var import_ignore = __toESM(require("ignore"));
+
+// src/utils/history-git.ts
+var import_child_process = require("child_process");
+function getFileCommitTimestamps(file) {
+  const lineStamps = {};
+  try {
+    const output = (0, import_child_process.execSync)(`git blame -t "${file}"`, {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const lines = output.split("\n");
+    for (const line of lines) {
+      if (!line) continue;
+      const match = line.match(/^\S+\s+\(.*?(\d{10,})\s+[-+]\d+\s+(\d+)\)/);
+      if (match) {
+        const ts = parseInt(match[1], 10);
+        const ln = parseInt(match[2], 10);
+        lineStamps[ln] = ts;
+      }
+    }
+  } catch {
+  }
+  return lineStamps;
+}
+function getLineRangeLastModifiedCached(lineStamps, startLine, endLine) {
+  let latest = 0;
+  for (let i = startLine; i <= endLine; i++) {
+    if (lineStamps[i] && lineStamps[i] > latest) {
+      latest = lineStamps[i];
+    }
+  }
+  return latest;
+}
+function getRepoMetadata(directory) {
+  const metadata = {};
+  try {
+    try {
+      metadata.url = (0, import_child_process.execSync)("git config --get remote.origin.url", {
+        cwd: directory,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+    } catch {
+    }
+    try {
+      metadata.branch = (0, import_child_process.execSync)("git rev-parse --abbrev-ref HEAD", {
+        cwd: directory,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+    } catch {
+    }
+    try {
+      metadata.commit = (0, import_child_process.execSync)("git rev-parse HEAD", {
+        cwd: directory,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+    } catch {
+    }
+    try {
+      metadata.author = (0, import_child_process.execSync)("git log -1 --format=%ae", {
+        cwd: directory,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+    } catch {
+    }
+  } catch {
+  }
+  return metadata;
+}
+function getChangedFiles(directory) {
+  const changedFiles = /* @__PURE__ */ new Set();
+  try {
+    const trackedOutput = (0, import_child_process.execSync)("git diff HEAD --name-only", {
+      cwd: directory,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (trackedOutput) {
+      trackedOutput.split("\n").forEach((f) => changedFiles.add(f));
+    }
+    const untrackedOutput = (0, import_child_process.execSync)(
+      "git ls-files --others --exclude-standard",
+      {
+        cwd: directory,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    ).trim();
+    if (untrackedOutput) {
+      untrackedOutput.split("\n").forEach((f) => changedFiles.add(f));
+    }
+  } catch {
+  }
+  return Array.from(changedFiles);
+}
+
+// src/utils/file-scanner.ts
 var DEFAULT_EXCLUDE = [
   // Dependencies
   "**/node_modules/**",
@@ -2866,12 +3025,12 @@ var VAGUE_FILE_NAMES = /* @__PURE__ */ new Set([
 ]);
 async function scanFiles(options) {
   const {
-    rootDir,
+    rootDir = ".",
     include = ["**/*.{ts,tsx,js,jsx,py,java,go,rs,cs}"],
     // Multi-language support
     exclude
   } = options;
-  const ignoreFilePath = (0, import_path.join)(rootDir || ".", ".aireadyignore");
+  const ignoreFilePath = (0, import_path.join)(rootDir, ".aireadyignore");
   let ignoreFromFile = [];
   if ((0, import_fs.existsSync)(ignoreFilePath)) {
     try {
@@ -2904,13 +3063,14 @@ async function scanFiles(options) {
     // Minimal ignore for gitignore discovery
     absolute: true
   });
+  let filtered = files;
   if (gitignoreFiles.length > 0) {
     try {
       const ig = (0, import_ignore.default)();
       for (const gitignorePath of gitignoreFiles) {
         const gitTxt = await (0, import_promises.readFile)(gitignorePath, "utf-8");
         const gitignoreDir = (0, import_path.dirname)(gitignorePath);
-        const relativePrefix = (0, import_path.relative)(rootDir || ".", gitignoreDir).replace(
+        const relativePrefix = (0, import_path.relative)(rootDir, gitignoreDir).replace(
           /\\/g,
           "/"
         );
@@ -2925,22 +3085,26 @@ async function scanFiles(options) {
           );
         }
       }
-      const filtered = files.filter((f) => {
-        let rel = (0, import_path.relative)(rootDir || ".", f).replace(/\\/g, "/");
+      filtered = files.filter((f) => {
+        let rel = (0, import_path.relative)(rootDir, f).replace(/\\/g, "/");
         if (rel === "") rel = f;
         return !ig.ignores(rel);
       });
-      return filtered;
     } catch {
-      return files;
     }
   }
-  return files;
+  if (options.changedFilesOnly) {
+    const changedFiles = getChangedFiles(rootDir).map(
+      (f) => (0, import_path.resolve)(rootDir, f)
+    );
+    return filtered.filter((f) => changedFiles.includes(f));
+  }
+  return filtered;
 }
 async function scanEntries(options) {
   const files = await scanFiles(options);
-  const { rootDir, exclude, includeTests } = options;
-  const ignoreFilePath = (0, import_path.join)(rootDir || ".", ".aireadyignore");
+  const { rootDir = ".", exclude, includeTests } = options;
+  const ignoreFilePath = (0, import_path.join)(rootDir, ".aireadyignore");
   let ignoreFromFile = [];
   if ((0, import_fs.existsSync)(ignoreFilePath)) {
     try {
@@ -2976,7 +3140,7 @@ async function scanEntries(options) {
     for (const gitignorePath of gitignoreFiles) {
       const gitTxt = await (0, import_promises.readFile)(gitignorePath, "utf-8");
       const gitignoreDir = (0, import_path.dirname)(gitignorePath);
-      const relativePrefix = (0, import_path.relative)(rootDir || ".", gitignoreDir).replace(
+      const relativePrefix = (0, import_path.relative)(rootDir, gitignoreDir).replace(
         /\\/g,
         "/"
       );
@@ -2992,7 +3156,7 @@ async function scanEntries(options) {
       }
     }
     const filteredDirs = dirs.filter((d) => {
-      let rel = (0, import_path.relative)(rootDir || ".", d).replace(/\\/g, "/");
+      let rel = (0, import_path.relative)(rootDir, d).replace(/\\/g, "/");
       if (rel === "") return true;
       if (!rel.endsWith("/")) rel += "/";
       return !ig.ignores(rel);
@@ -3048,13 +3212,20 @@ function resolveOutputPath(userPath, defaultFilename, workingDir = process.cwd()
   ensureDir(outputPath);
   return outputPath;
 }
+function safeJsonStringify(obj, indent = 2) {
+  return JSON.stringify(
+    obj,
+    (_, v) => typeof v === "bigint" ? v.toString() : v,
+    indent
+  );
+}
 function handleJSONOutput(data, outputFile, successMessage) {
   if (outputFile) {
     ensureDir(outputFile);
-    (0, import_fs2.writeFileSync)(outputFile, JSON.stringify(data, null, 2));
+    (0, import_fs2.writeFileSync)(outputFile, safeJsonStringify(data, 2));
     console.log(successMessage || `\u2705 Results saved to ${outputFile}`);
   } else {
-    console.log(JSON.stringify(data, null, 2));
+    console.log(safeJsonStringify(data, 2));
   }
 }
 function findLatestReport(dirPath) {
@@ -3245,7 +3416,7 @@ function handleCLIError(error, commandName) {
 
 // src/utils/cli-helpers.ts
 async function loadMergedConfig(directory, defaults, cliOptions) {
-  const config = await loadConfig(directory);
+  const { config } = await loadConfig(directory);
   const mergedConfig = mergeConfigWithDefaults(config, defaults);
   const result = {
     ...mergedConfig,
@@ -3780,8 +3951,7 @@ function estimateTokens(text) {
 
 // src/utils/config.ts
 var import_fs3 = require("fs");
-var import_path4 = require("path");
-var import_url2 = require("url");
+var import_path5 = require("path");
 var CONFIG_FILES = [
   "aiready.json",
   "aiready.config.json",
@@ -3790,12 +3960,164 @@ var CONFIG_FILES = [
   "aiready.config.js",
   ".aireadyrc.js"
 ];
-async function loadConfig(rootDir) {
-  let currentDir = (0, import_path4.resolve)(rootDir);
+var DEFAULT_AUTO_EXCLUDE_PATTERNS = {
+  tests: [
+    "**/*.test.ts",
+    "**/*.test.tsx",
+    "**/*.test.js",
+    "**/*.test.jsx",
+    "**/*.spec.ts",
+    "**/*.spec.tsx",
+    "**/*.spec.js",
+    "**/*.spec.jsx",
+    "**/__tests__/**",
+    "**/tests/**"
+  ],
+  mocks: [
+    "**/__mocks__/**",
+    "**/*.mock.ts",
+    "**/*.mock.tsx",
+    "**/*.mock.js",
+    "**/*.mock.jsx"
+  ],
+  barrels: ["**/index.ts", "**/index.js"],
+  generated: [
+    "**/.next/**",
+    "**/.sst/**",
+    "**/.cache/**",
+    "**/dist/**",
+    "**/build/**"
+  ]
+};
+function deepMerge(base, override) {
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    const baseVal = base[key];
+    const overrideVal = override[key];
+    if (baseVal && overrideVal && typeof baseVal === "object" && typeof overrideVal === "object" && !Array.isArray(baseVal) && !Array.isArray(overrideVal)) {
+      result[key] = deepMerge(baseVal, overrideVal);
+    } else if (overrideVal !== void 0) {
+      result[key] = overrideVal;
+    }
+  }
+  return result;
+}
+function checkPatternWarnings(config, configPath) {
+  const warnings = [];
+  const excludeArray = Array.isArray(config.exclude) ? config.exclude : config.exclude ? Object.values(config.exclude).flat() : [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const pattern of excludeArray) {
+    if (seen.has(pattern)) {
+      warnings.push({
+        rule: "duplicate-exclude",
+        message: `Duplicate pattern '${pattern}' in exclude array`
+      });
+    }
+    seen.add(pattern);
+    if (pattern.match(/^\*\*\/[^/]+\.[^/]+$/)) {
+      warnings.push({
+        rule: "single-file-glob",
+        message: `Single-file glob '${pattern}' - use without ** prefix`,
+        suggestion: pattern.replace(/^\*\*\//, "")
+      });
+    }
+    const normalized = pattern.replace(/^\*\*\//, "").replace(/^\*\//, "");
+    for (const other of seen) {
+      if (other === pattern) continue;
+      const otherNormalized = other.replace(/^\*\*\//, "").replace(/^\*\//, "");
+      if (normalized === otherNormalized) {
+        warnings.push({
+          rule: "overlapping-pattern",
+          message: `Patterns '${pattern}' and '${other}' likely match the same files`
+        });
+      }
+    }
+  }
+  if (config.extends) {
+    warnings.push({
+      rule: "config-inheritance",
+      message: `Config extends '${config.extends}' - ensure base config exists`
+    });
+  }
+  return warnings;
+}
+function resolveConfigPath(extendsPath, baseConfigPath) {
+  const baseDir = (0, import_path5.dirname)(baseConfigPath);
+  return (0, import_path5.resolve)(baseDir, extendsPath);
+}
+async function loadConfigWithInheritance(configPath, alreadyLoaded = /* @__PURE__ */ new Set()) {
+  const resolvedPath = (0, import_path5.resolve)(configPath);
+  if (alreadyLoaded.has(resolvedPath)) {
+    throw new Error(
+      `Circular config inheritance detected: ${Array.from(alreadyLoaded).join(" -> ")} -> ${resolvedPath}`
+    );
+  }
+  alreadyLoaded.add(resolvedPath);
+  const content = (0, import_fs3.readFileSync)(resolvedPath, "utf-8");
+  let rawConfig = JSON.parse(content);
+  const warnings = [];
+  const legacyKeys = ["toolConfigs", "scanConfig", "aiReady"];
+  const foundLegacy = legacyKeys.filter((key) => key in rawConfig);
+  if (foundLegacy.length > 0) {
+    console.warn(
+      `\u26A0\uFE0F Legacy configuration keys found: ${foundLegacy.join(", ")}. Please migrate to the new schema.`
+    );
+  }
+  if (rawConfig.extends) {
+    const baseConfigPath = resolveConfigPath(rawConfig.extends, resolvedPath);
+    if (!(0, import_fs3.existsSync)(baseConfigPath)) {
+      throw new Error(
+        `Base config not found: ${rawConfig.extends} (resolved to ${baseConfigPath})`
+      );
+    }
+    const baseResult = await loadConfigWithInheritance(
+      baseConfigPath,
+      alreadyLoaded
+    );
+    rawConfig = deepMerge(baseResult.config, rawConfig);
+    warnings.push(...baseResult.warnings);
+  }
+  warnings.push(...checkPatternWarnings(rawConfig, resolvedPath));
+  const config = AIReadyConfigSchema.parse(rawConfig);
+  return { config, warnings };
+}
+function applyAutoExclusions(config, projectRoot) {
+  const autoExclude = config.autoExclude ?? {
+    tests: true,
+    mocks: true,
+    barrels: false,
+    generated: true
+  };
+  if (!autoExclude.tests && !autoExclude.mocks && !autoExclude.barrels && !autoExclude.generated) {
+    return config;
+  }
+  const patterns = [];
+  if (autoExclude.tests) {
+    patterns.push(...DEFAULT_AUTO_EXCLUDE_PATTERNS.tests);
+  }
+  if (autoExclude.mocks) {
+    patterns.push(...DEFAULT_AUTO_EXCLUDE_PATTERNS.mocks);
+  }
+  if (autoExclude.barrels) {
+    patterns.push(...DEFAULT_AUTO_EXCLUDE_PATTERNS.barrels);
+  }
+  if (autoExclude.generated) {
+    patterns.push(...DEFAULT_AUTO_EXCLUDE_PATTERNS.generated);
+  }
+  const existingExclude = config.exclude ?? [];
+  const existingArray = Array.isArray(existingExclude) ? existingExclude : existingExclude?.global ?? [];
+  return {
+    ...config,
+    exclude: [...existingArray, ...patterns]
+  };
+}
+async function loadConfig(rootDir, options) {
+  const warnings = [];
+  let currentDir = (0, import_path5.resolve)(rootDir);
   while (true) {
     const foundConfigs = [];
     for (const configFile of CONFIG_FILES) {
-      if ((0, import_fs3.existsSync)((0, import_path4.join)(currentDir, configFile))) {
+      if ((0, import_fs3.existsSync)((0, import_path5.join)(currentDir, configFile))) {
         foundConfigs.push(configFile);
       }
     }
@@ -3806,39 +4128,17 @@ async function loadConfig(rootDir) {
             ", "
           )}. Using ${foundConfigs[0]}.`
         );
-      } else {
       }
       const configFile = foundConfigs[0];
-      const configPath = (0, import_path4.join)(currentDir, configFile);
+      const configPath = (0, import_path5.join)(currentDir, configFile);
       try {
-        let config;
-        if (configFile.endsWith(".js")) {
-          const fileUrl = (0, import_url2.pathToFileURL)(configPath).href;
-          const module2 = await import(`${fileUrl}?t=${Date.now()}`);
-          config = module2.default || module2;
-        } else {
-          const content = (0, import_fs3.readFileSync)(configPath, "utf-8");
-          config = JSON.parse(content);
+        const result = await loadConfigWithInheritance(configPath);
+        warnings.push(...result.warnings);
+        let config = result.config;
+        if (options?.applyAutoExclude !== false) {
+          config = applyAutoExclusions(config, currentDir);
         }
-        const legacyKeys = ["toolConfigs"];
-        const rootLevelTools = [
-          "pattern-detect",
-          "context-analyzer",
-          "naming-consistency",
-          "ai-signal-clarity"
-        ];
-        const allKeys = Object.keys(config);
-        const foundLegacy = allKeys.filter(
-          (k) => legacyKeys.includes(k) || rootLevelTools.includes(k)
-        );
-        if (foundLegacy.length > 0) {
-          console.warn(
-            `\u26A0\uFE0F Legacy configuration keys found: ${foundLegacy.join(
-              ", "
-            )}. These are deprecated and should be moved under the "tools" key.`
-          );
-        }
-        return AIReadyConfigSchema.parse(config);
+        return { config, warnings };
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         const configError = new Error(
@@ -3851,13 +4151,27 @@ async function loadConfig(rootDir) {
         throw configError;
       }
     }
-    const parent = (0, import_path4.dirname)(currentDir);
+    const parent = (0, import_path5.dirname)(currentDir);
     if (parent === currentDir) {
       break;
     }
     currentDir = parent;
   }
-  return null;
+  return { config: null, warnings };
+}
+function validateConfig(configPath) {
+  try {
+    const content = (0, import_fs3.readFileSync)(configPath, "utf-8");
+    const config = JSON.parse(content);
+    return checkPatternWarnings(config, configPath);
+  } catch (error) {
+    return [
+      {
+        rule: "parse-error",
+        message: `Failed to parse config: ${error instanceof Error ? error.message : String(error)}`
+      }
+    ];
+  }
 }
 function mergeConfigWithDefaults(userConfig, defaults) {
   if (!userConfig) return defaults;
@@ -5003,6 +5317,9 @@ function extractBlocksPython(file, content) {
   return blocks;
 }
 
+// src/index.ts
+init_path_utils();
+
 // src/business/pricing-models.ts
 var MODEL_PRICING_PRESETS = {
   "gpt-5.4-mini": {
@@ -6565,9 +6882,9 @@ function calculateChangeAmplification(params) {
 
 // src/utils/history.ts
 var import_fs4 = require("fs");
-var import_path5 = require("path");
+var import_path6 = require("path");
 function getHistoryPath(rootDir) {
-  return (0, import_path5.join)(rootDir, ".aiready", "history.json");
+  return (0, import_path6.join)(rootDir, ".aiready", "history.json");
 }
 function loadScoreHistory(rootDir) {
   const historyPath = getHistoryPath(rootDir);
@@ -6584,7 +6901,7 @@ function loadScoreHistory(rootDir) {
 }
 function saveScoreEntry(rootDir, entry) {
   const historyPath = getHistoryPath(rootDir);
-  const historyDir = (0, import_path5.dirname)(historyPath);
+  const historyDir = (0, import_path6.dirname)(historyPath);
   if (!(0, import_fs4.existsSync)(historyDir)) {
     (0, import_fs4.mkdirSync)(historyDir, { recursive: true });
   }
@@ -6637,78 +6954,6 @@ function clearHistory(rootDir) {
   }
 }
 
-// src/utils/history-git.ts
-var import_child_process = require("child_process");
-function getFileCommitTimestamps(file) {
-  const lineStamps = {};
-  try {
-    const output = (0, import_child_process.execSync)(`git blame -t "${file}"`, {
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    const lines = output.split("\n");
-    for (const line of lines) {
-      if (!line) continue;
-      const match = line.match(/^\S+\s+\(.*?(\d{10,})\s+[-+]\d+\s+(\d+)\)/);
-      if (match) {
-        const ts = parseInt(match[1], 10);
-        const ln = parseInt(match[2], 10);
-        lineStamps[ln] = ts;
-      }
-    }
-  } catch {
-  }
-  return lineStamps;
-}
-function getLineRangeLastModifiedCached(lineStamps, startLine, endLine) {
-  let latest = 0;
-  for (let i = startLine; i <= endLine; i++) {
-    if (lineStamps[i] && lineStamps[i] > latest) {
-      latest = lineStamps[i];
-    }
-  }
-  return latest;
-}
-function getRepoMetadata(directory) {
-  const metadata = {};
-  try {
-    try {
-      metadata.url = (0, import_child_process.execSync)("git config --get remote.origin.url", {
-        cwd: directory,
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "ignore"]
-      }).trim();
-    } catch {
-    }
-    try {
-      metadata.branch = (0, import_child_process.execSync)("git rev-parse --abbrev-ref HEAD", {
-        cwd: directory,
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "ignore"]
-      }).trim();
-    } catch {
-    }
-    try {
-      metadata.commit = (0, import_child_process.execSync)("git rev-parse HEAD", {
-        cwd: directory,
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "ignore"]
-      }).trim();
-    } catch {
-    }
-    try {
-      metadata.author = (0, import_child_process.execSync)("git log -1 --format=%ae", {
-        cwd: directory,
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "ignore"]
-      }).trim();
-    } catch {
-    }
-  } catch {
-  }
-  return metadata;
-}
-
 // src/utils/github-utils.ts
 function emitAnnotation(params) {
   const { level, file, line, col, title, message } = params;
@@ -6797,7 +7042,7 @@ Found ${issues.length} issues.`));
 
 // src/utils/test-utils.ts
 var import_fs5 = require("fs");
-var import_path6 = require("path");
+var import_path7 = require("path");
 var TEST_PATTERNS = [
   // TypeScript/JavaScript test files
   /\.(test|spec)\.(ts|tsx|js|jsx)$/,
@@ -6862,7 +7107,7 @@ function detectTestFramework(rootDir) {
     // go testing is built-in
   ];
   for (const m of manifests) {
-    const p = (0, import_path6.join)(rootDir, m.file);
+    const p = (0, import_path7.join)(rootDir, m.file);
     if ((0, import_fs5.existsSync)(p)) {
       if (m.file === "go.mod") return true;
       try {
@@ -6920,6 +7165,188 @@ async function withErrorHandling(operation, context) {
     return { success: false, error: `${contextPrefix}${message}` };
   }
 }
+
+// src/growth/agents.ts
+var import_child_process2 = require("child_process");
+var GitHubIssueResolverAgent = class {
+  constructor(options) {
+    this.generate = options.generate;
+    if (!options.trustedAuthors || options.trustedAuthors.length === 0) {
+      throw new Error(
+        "[GitHubIssueResolverAgent] Security Error: trustedAuthors must be explicitly configured."
+      );
+    }
+    this.trustedAuthors = options.trustedAuthors;
+  }
+  async resolve(issue, workingDir) {
+    console.log(
+      `[GitHubIssueResolverAgent] Resolving issue #${issue.number}: ${issue.title}`
+    );
+    const strategy = await this.identifyStrategy(issue);
+    console.log(`[GitHubIssueResolverAgent] Selected Strategy: ${strategy}`);
+    try {
+      switch (strategy) {
+        case "CORE_EVOLUTION_SYNC":
+          if (issue.author && !this.trustedAuthors.includes(issue.author)) {
+            console.warn(
+              `[GitHubIssueResolverAgent] Unauthorized evolution attempt by ${issue.author}. Blocking.`
+            );
+            return {
+              success: false,
+              message: `Unauthorized actor: ${issue.author} is not in trustedAuthors list.`
+            };
+          }
+          return await this.executeSubtreeSync(issue, workingDir);
+        case "EVOLUTION_CONTRIBUTION":
+          return await this.applyContributionPattern(issue, workingDir);
+        case "BUG_FIX":
+          return await this.applyAgenticPatch(issue, workingDir);
+        default:
+          return { success: false, message: `Unknown strategy: ${strategy}` };
+      }
+    } catch (error) {
+      console.error(
+        `[GitHubIssueResolverAgent] Resolution failed for issue #${issue.number}:`,
+        error.message
+      );
+      return {
+        success: false,
+        message: `Resolution failed: ${error.message}`
+      };
+    }
+  }
+  async identifyStrategy(issue) {
+    if (issue.labels.includes("evolution-sync")) return "CORE_EVOLUTION_SYNC";
+    if (issue.labels.includes("evolution-contribution"))
+      return "EVOLUTION_CONTRIBUTION";
+    if (issue.labels.includes("bug")) return "BUG_FIX";
+    const prompt = `
+      Analyze the GitHub Issue:
+      Title: ${issue.title}
+      Labels: ${issue.labels.join(", ")}
+
+      Categorize into: CORE_EVOLUTION_SYNC, EVOLUTION_CONTRIBUTION, BUG_FIX, or UNKNOWN.
+      Only return the category name.
+    `;
+    return (await this.generate(prompt)).trim();
+  }
+  async executeSubtreeSync(issue, workingDir) {
+    const hubVersion = this.extractVersion(issue.body);
+    const prefix = "core/";
+    const hubUrl = "https://github.com/serverlessclaw/serverlessclaw.git";
+    console.log(
+      `[GitHubIssueResolverAgent] Performing Subtree Pull (Hub v${hubVersion}) into ${workingDir}...`
+    );
+    try {
+      try {
+        (0, import_child_process2.execSync)(`git remote add hub ${hubUrl}`, {
+          cwd: workingDir,
+          stdio: "ignore"
+        });
+      } catch (e) {
+        if (!e.message.includes("already exists")) {
+          console.warn(
+            `[GitHubIssueResolverAgent] Remote add warning: ${e.message}`
+          );
+        }
+      }
+      (0, import_child_process2.execSync)(`git fetch hub`, { cwd: workingDir, stdio: "pipe" });
+      console.log(
+        `[GitHubIssueResolverAgent] Executing subtree pull for v${hubVersion}...`
+      );
+      (0, import_child_process2.execSync)(
+        `git subtree pull --prefix=${prefix} hub ${hubVersion} --squash -m "chore(sync): evolution upgrade to ${hubVersion}"`,
+        {
+          cwd: workingDir,
+          env: { ...process.env, GIT_MERGE_AUTOEDIT: "no" }
+        }
+      );
+      return {
+        success: true,
+        message: `Successfully sync'd Hub ${hubVersion} via subtree merge`
+      };
+    } catch (error) {
+      console.error(
+        `[GitHubIssueResolverAgent] Subtree sync failed: ${error.message}`
+      );
+      throw new Error(`Subtree sync failed: ${error.message}`, {
+        cause: error
+      });
+    }
+  }
+  async applyContributionPattern(issue, workingDir) {
+    console.log(
+      `[GitHubIssueResolverAgent] Pattern absorption requested: ${issue.title}`
+    );
+    return {
+      success: true,
+      message: `Contribution strategy identified. Pattern "${issue.title}" is ready for human screening and promotion.`
+    };
+  }
+  async applyAgenticPatch(issue, workingDir) {
+    console.log(`[GitHubIssueResolverAgent] Bug fix requested: ${issue.title}`);
+    return {
+      success: true,
+      message: `Patch strategy identified. Agentic fix for "${issue.title}" is being drafted.`
+    };
+  }
+  extractVersion(body) {
+    const match = body.match(/v\d+\.\d+\.\d+/);
+    if (match) return match[0];
+    const branchMatch = body.match(/branch:?\s*([a-zA-Z0-9.\-_/]+)/i);
+    if (branchMatch) return branchMatch[1];
+    return "main";
+  }
+};
+
+// src/services/github-service.ts
+var import_rest = require("@octokit/rest");
+var GitHubService = class {
+  constructor(token) {
+    this.octokit = new import_rest.Octokit({ auth: token });
+  }
+  /**
+   * Creates an issue in a repository.
+   */
+  async createHubIssue(owner, repo, issue) {
+    const { data } = await this.octokit.issues.create({
+      owner,
+      repo,
+      title: issue.title,
+      body: issue.body,
+      labels: issue.labels || ["innovation-harvest"]
+    });
+    return data.number;
+  }
+  /**
+   * Creates a Pull Request in a repository.
+   */
+  async createPullRequest(owner, repo, pr) {
+    const { data } = await this.octokit.pulls.create({
+      owner,
+      repo,
+      title: pr.title,
+      body: pr.body,
+      head: pr.head,
+      base: pr.base
+    });
+    return data.number;
+  }
+  /**
+   * Scans a repository content.
+   */
+  async listRecentChangesInRepo(owner, repo, path2 = "") {
+    const { data } = await this.octokit.repos.getContent({
+      owner,
+      repo,
+      path: path2
+    });
+    if (Array.isArray(data)) {
+      return data.map((file) => file.path);
+    }
+    return [];
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AIReadyConfigSchema,
@@ -6930,6 +7357,7 @@ async function withErrorHandling(operation, context) {
   COMMON_FINE_TUNING_OPTIONS,
   CONTEXT_TIER_THRESHOLDS,
   CSharpParser,
+  DEFAULT_AUTO_EXCLUDE_PATTERNS,
   DEFAULT_COST_CONFIG,
   DEFAULT_EXCLUDE,
   DEFAULT_TOOL_WEIGHTS,
@@ -6938,6 +7366,8 @@ async function withErrorHandling(operation, context) {
   FRIENDLY_TOOL_NAMES,
   GLOBAL_INFRA_OPTIONS,
   GLOBAL_SCAN_OPTIONS,
+  GitHubIssueResolverAgent,
+  GitHubService,
   GoParser,
   IssueSchema,
   IssueType,
@@ -7042,6 +7472,8 @@ async function withErrorHandling(operation, context) {
   generateStatCards,
   generateTable,
   generateValueChain,
+  getChangedFiles,
+  getDirname,
   getElapsedTime,
   getErrorMessage,
   getFileCommitTimestamps,
@@ -7110,12 +7542,14 @@ async function withErrorHandling(operation, context) {
   resolveOutputPath,
   runBatchAnalysis,
   runStandardCliAction,
+  safeJsonStringify,
   saveScoreEntry,
   scanEntries,
   scanFiles,
   setupParser,
   severityToAnnotationLevel,
   toErrorMessage,
+  validateConfig,
   validateSpokeOutput,
   validateWithSchema,
   withErrorHandling,