@aiready/core 0.24.23 → 0.24.25

package/dist/index.mjs

@@ -52,28 +52,29 @@ import {
   getToolWeight,
   normalizeToolName,
   parseWeightString
-} from "./chunk-BE52N7T2.mjs";
+} from "./chunk-OAH6FVVF.mjs";
 import {
   TypeScriptParser
-} from "./chunk-WPFXQH5F.mjs";
+} from "./chunk-X64EJ3ZO.mjs";
 import {
   PythonParser
-} from "./chunk-QY5YG2AZ.mjs";
+} from "./chunk-T2FW6AAF.mjs";
 import {
   JavaParser
-} from "./chunk-6T5O7OAY.mjs";
+} from "./chunk-TQX77RIC.mjs";
 import {
   CSharpParser
-} from "./chunk-EHUK4VMH.mjs";
+} from "./chunk-G737F72Q.mjs";
 import {
   GoParser
-} from "./chunk-EJ74KPCV.mjs";
+} from "./chunk-OCM6HLBM.mjs";
 import "./chunk-3D3I5K5W.mjs";
 import {
+  getDirname,
   getWasmPath,
   initTreeSitter,
   setupParser
-} from "./chunk-2N7ISIKE.mjs";
+} from "./chunk-LRPBPWBM.mjs";
 import {
   LANGUAGE_EXTENSIONS,
   Language,
@@ -334,8 +335,108 @@ var ToolRegistry = class _ToolRegistry {
 import { glob } from "glob";
 import { readFile } from "fs/promises";
 import { existsSync } from "fs";
-import { join, relative, dirname } from "path";
+import { join, relative, dirname, resolve } from "path";
 import ignorePkg from "ignore";
+
+// src/utils/history-git.ts
+import { execSync } from "child_process";
+function getFileCommitTimestamps(file) {
+  const lineStamps = {};
+  try {
+    const output = 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 = execSync("git config --get remote.origin.url", {
+        cwd: directory,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+    } catch {
+    }
+    try {
+      metadata.branch = execSync("git rev-parse --abbrev-ref HEAD", {
+        cwd: directory,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+    } catch {
+    }
+    try {
+      metadata.commit = execSync("git rev-parse HEAD", {
+        cwd: directory,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }).trim();
+    } catch {
+    }
+    try {
+      metadata.author = 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 = 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 = 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/**",
@@ -407,12 +508,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 = join(rootDir || ".", ".aireadyignore");
+  const ignoreFilePath = join(rootDir, ".aireadyignore");
   let ignoreFromFile = [];
   if (existsSync(ignoreFilePath)) {
     try {
@@ -445,13 +546,14 @@ async function scanFiles(options) {
     // Minimal ignore for gitignore discovery
     absolute: true
   });
+  let filtered = files;
   if (gitignoreFiles.length > 0) {
     try {
       const ig = ignorePkg();
       for (const gitignorePath of gitignoreFiles) {
         const gitTxt = await readFile(gitignorePath, "utf-8");
         const gitignoreDir = dirname(gitignorePath);
-        const relativePrefix = relative(rootDir || ".", gitignoreDir).replace(
+        const relativePrefix = relative(rootDir, gitignoreDir).replace(
           /\\/g,
           "/"
         );
@@ -466,22 +568,26 @@ async function scanFiles(options) {
           );
         }
       }
-      const filtered = files.filter((f) => {
-        let rel = relative(rootDir || ".", f).replace(/\\/g, "/");
+      filtered = files.filter((f) => {
+        let rel = 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) => 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 = join(rootDir || ".", ".aireadyignore");
+  const { rootDir = ".", exclude, includeTests } = options;
+  const ignoreFilePath = join(rootDir, ".aireadyignore");
   let ignoreFromFile = [];
   if (existsSync(ignoreFilePath)) {
     try {
@@ -517,7 +623,7 @@ async function scanEntries(options) {
     for (const gitignorePath of gitignoreFiles) {
       const gitTxt = await readFile(gitignorePath, "utf-8");
       const gitignoreDir = dirname(gitignorePath);
-      const relativePrefix = relative(rootDir || ".", gitignoreDir).replace(
+      const relativePrefix = relative(rootDir, gitignoreDir).replace(
         /\\/g,
         "/"
       );
@@ -533,7 +639,7 @@ async function scanEntries(options) {
       }
     }
     const filteredDirs = dirs.filter((d) => {
-      let rel = relative(rootDir || ".", d).replace(/\\/g, "/");
+      let rel = relative(rootDir, d).replace(/\\/g, "/");
       if (rel === "") return true;
       if (!rel.endsWith("/")) rel += "/";
       return !ig.ignores(rel);
@@ -595,13 +701,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);
-    writeFileSync(outputFile, JSON.stringify(data, null, 2));
+    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) {
@@ -792,7 +905,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,
@@ -954,27 +1067,27 @@ var ParserFactory = class _ParserFactory {
       Object.entries(LANGUAGE_EXTENSIONS).map(([ext, lang]) => [ext, lang])
     );
     this.registerLazyParser("typescript" /* TypeScript */, async () => {
-      const { TypeScriptParser: TypeScriptParser2 } = await import("./typescript-parser-WALISXF4.mjs");
+      const { TypeScriptParser: TypeScriptParser2 } = await import("./typescript-parser-5ZWLLMWJ.mjs");
       return new TypeScriptParser2();
     });
     this.registerLazyParser("javascript" /* JavaScript */, async () => {
-      const { TypeScriptParser: TypeScriptParser2 } = await import("./typescript-parser-WALISXF4.mjs");
+      const { TypeScriptParser: TypeScriptParser2 } = await import("./typescript-parser-5ZWLLMWJ.mjs");
       return new TypeScriptParser2();
     });
     this.registerLazyParser("python" /* Python */, async () => {
-      const { PythonParser: PythonParser2 } = await import("./python-parser-7NCR7VCQ.mjs");
+      const { PythonParser: PythonParser2 } = await import("./python-parser-WIJPSRKC.mjs");
       return new PythonParser2();
     });
     this.registerLazyParser("java" /* Java */, async () => {
-      const { JavaParser: JavaParser2 } = await import("./java-parser-WGOXKULP.mjs");
+      const { JavaParser: JavaParser2 } = await import("./java-parser-YP5XWLQK.mjs");
       return new JavaParser2();
     });
     this.registerLazyParser("csharp" /* CSharp */, async () => {
-      const { CSharpParser: CSharpParser2 } = await import("./csharp-parser-JE5MWHQS.mjs");
+      const { CSharpParser: CSharpParser2 } = await import("./csharp-parser-WIAIE3DD.mjs");
       return new CSharpParser2();
     });
     this.registerLazyParser("go" /* Go */, async () => {
-      const { GoParser: GoParser2 } = await import("./go-parser-T7PR6WJI.mjs");
+      const { GoParser: GoParser2 } = await import("./go-parser-Q3HI32B7.mjs");
       return new GoParser2();
     });
   }
@@ -1323,8 +1436,7 @@ function estimateTokens(text) {
 
 // src/utils/config.ts
 import { readFileSync, existsSync as existsSync3 } from "fs";
-import { join as join3, resolve, dirname as dirname3 } from "path";
-import { pathToFileURL } from "url";
+import { join as join3, resolve as resolve2, dirname as dirname3 } from "path";
 var CONFIG_FILES = [
   "aiready.json",
   "aiready.config.json",
@@ -1333,8 +1445,160 @@ var CONFIG_FILES = [
   "aiready.config.js",
   ".aireadyrc.js"
 ];
-async function loadConfig(rootDir) {
-  let currentDir = 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 = dirname3(baseConfigPath);
+  return resolve2(baseDir, extendsPath);
+}
+async function loadConfigWithInheritance(configPath, alreadyLoaded = /* @__PURE__ */ new Set()) {
+  const resolvedPath = resolve2(configPath);
+  if (alreadyLoaded.has(resolvedPath)) {
+    throw new Error(
+      `Circular config inheritance detected: ${Array.from(alreadyLoaded).join(" -> ")} -> ${resolvedPath}`
+    );
+  }
+  alreadyLoaded.add(resolvedPath);
+  const content = 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 (!existsSync3(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 = resolve2(rootDir);
   while (true) {
     const foundConfigs = [];
     for (const configFile of CONFIG_FILES) {
@@ -1349,39 +1613,17 @@ async function loadConfig(rootDir) {
             ", "
           )}. Using ${foundConfigs[0]}.`
         );
-      } else {
       }
       const configFile = foundConfigs[0];
       const configPath = join3(currentDir, configFile);
       try {
-        let config;
-        if (configFile.endsWith(".js")) {
-          const fileUrl = pathToFileURL(configPath).href;
-          const module = await import(`${fileUrl}?t=${Date.now()}`);
-          config = module.default || module;
-        } else {
-          const content = 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(
@@ -1400,7 +1642,21 @@ async function loadConfig(rootDir) {
     }
     currentDir = parent;
   }
-  return null;
+  return { config: null, warnings };
+}
+function validateConfig(configPath) {
+  try {
+    const content = 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;
@@ -3644,78 +3900,6 @@ function clearHistory(rootDir) {
   }
 }
 
-// src/utils/history-git.ts
-import { execSync } from "child_process";
-function getFileCommitTimestamps(file) {
-  const lineStamps = {};
-  try {
-    const output = 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 = execSync("git config --get remote.origin.url", {
-        cwd: directory,
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "ignore"]
-      }).trim();
-    } catch {
-    }
-    try {
-      metadata.branch = execSync("git rev-parse --abbrev-ref HEAD", {
-        cwd: directory,
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "ignore"]
-      }).trim();
-    } catch {
-    }
-    try {
-      metadata.commit = execSync("git rev-parse HEAD", {
-        cwd: directory,
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "ignore"]
-      }).trim();
-    } catch {
-    }
-    try {
-      metadata.author = 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;
@@ -3927,6 +4111,188 @@ async function withErrorHandling(operation, context) {
     return { success: false, error: `${contextPrefix}${message}` };
   }
 }
+
+// src/growth/agents.ts
+import { execSync as execSync2 } from "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 {
+        execSync2(`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}`
+          );
+        }
+      }
+      execSync2(`git fetch hub`, { cwd: workingDir, stdio: "pipe" });
+      console.log(
+        `[GitHubIssueResolverAgent] Executing subtree pull for v${hubVersion}...`
+      );
+      execSync2(
+        `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
+import { Octokit } from "@octokit/rest";
+var GitHubService = class {
+  constructor(token) {
+    this.octokit = new 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, path = "") {
+    const { data } = await this.octokit.repos.getContent({
+      owner,
+      repo,
+      path
+    });
+    if (Array.isArray(data)) {
+      return data.map((file) => file.path);
+    }
+    return [];
+  }
+};
 export {
   AIReadyConfigSchema,
   AWS_CONSTANTS,
@@ -3936,6 +4302,7 @@ export {
   COMMON_FINE_TUNING_OPTIONS,
   CONTEXT_TIER_THRESHOLDS,
   CSharpParser,
+  DEFAULT_AUTO_EXCLUDE_PATTERNS,
   DEFAULT_COST_CONFIG,
   DEFAULT_EXCLUDE,
   DEFAULT_TOOL_WEIGHTS,
@@ -3944,6 +4311,8 @@ export {
   FRIENDLY_TOOL_NAMES,
   GLOBAL_INFRA_OPTIONS,
   GLOBAL_SCAN_OPTIONS,
+  GitHubIssueResolverAgent,
+  GitHubService,
   GoParser,
   IssueSchema,
   IssueType,
@@ -4048,6 +4417,8 @@ export {
   generateStatCards,
   generateTable,
   generateValueChain,
+  getChangedFiles,
+  getDirname,
   getElapsedTime,
   getErrorMessage,
   getFileCommitTimestamps,
@@ -4116,12 +4487,14 @@ export {
   resolveOutputPath,
   runBatchAnalysis,
   runStandardCliAction,
+  safeJsonStringify,
   saveScoreEntry,
   scanEntries,
   scanFiles,
   setupParser,
   severityToAnnotationLevel,
   toErrorMessage,
+  validateConfig,
   validateSpokeOutput,
   validateWithSchema,
   withErrorHandling,