@eldrforge/ai-service 0.1.21 → 0.1.22

package/dist/index.js

@@ -1706,8 +1706,8 @@ async function runAgenticCommit(config) {
     explainWhenToUse: true,
     includeCategories: true
   });
-  const systemPrompt = buildSystemPrompt$2(toolGuidance);
-  const userMessage = buildUserMessage$1(changedFiles, diffContent, userDirection, logContext);
+  const systemPrompt = buildSystemPrompt$3(toolGuidance);
+  const userMessage = buildUserMessage$2(changedFiles, diffContent, userDirection, logContext);
   const messages = [
     { role: "system", content: systemPrompt },
     { role: "user", content: userMessage }
@@ -1741,7 +1741,7 @@ async function runAgenticCommit(config) {
     toolMetrics: result.toolMetrics
   };
 }
-function buildSystemPrompt$2(toolGuidance) {
+function buildSystemPrompt$3(toolGuidance) {
   return `You are a professional software engineer writing commit messages for your team.
 
 ${toolGuidance}
@@ -1850,7 +1850,7 @@ Split 3:
 
 Output only the commit message and splits. No conversational remarks or follow-up offers.`;
 }
-function buildUserMessage$1(changedFiles, diffContent, userDirection, logContext) {
+function buildUserMessage$2(changedFiles, diffContent, userDirection, logContext) {
   const fileCount = changedFiles.length;
   const manyFiles = fileCount >= 5;
   let message = `I have staged changes that need a commit message.
@@ -1893,6 +1893,20 @@ If context information is provided, use it only if relevant to these specific ch
 Don't force connections that don't exist - focus on what actually changed.`;
   return message;
 }
+function sanitizeFilePath(filePath) {
+  return filePath.trim().replace(/^[-*]\s*/, "").replace(/^["']|["']$/g, "").replace(/\s*\([^)]*\)\s*$/, "").replace(/^["']|["']$/g, "").trim();
+}
+function parseFilesText(filesText) {
+  if (filesText.startsWith("[") && filesText.includes("]")) {
+    const closeIndex = filesText.indexOf("]");
+    const bracketed = filesText.slice(1, closeIndex);
+    return bracketed.split(",").map((f) => sanitizeFilePath(f)).filter((f) => f.length > 0);
+  }
+  if (filesText.match(/^["']/) && filesText.includes('", "')) {
+    return filesText.split(/["'],\s*["']/).map((f) => sanitizeFilePath(f)).filter((f) => f.length > 0);
+  }
+  return filesText.split("\n").map((line) => sanitizeFilePath(line)).filter((line) => line.length > 0);
+}
 function parseAgenticResult$1(finalMessage) {
   const commitMatch = finalMessage.match(/COMMIT_MESSAGE:\s*\n([\s\S]*?)(?=\n\nSUGGESTED_SPLITS:|$)/);
   const commitMessage = commitMatch ? commitMatch[1].trim() : finalMessage.trim();
@@ -1904,13 +1918,7 @@ function parseAgenticResult$1(finalMessage) {
     let match;
     while ((match = splitRegex.exec(splitsText)) !== null) {
       const filesText = match[1].trim();
-      let files = [];
-      if (filesText.startsWith("[") && filesText.endsWith("]")) {
-        const bracketed = filesText.slice(1, -1);
-        files = bracketed.split(",").map((f) => f.trim()).filter((f) => f.length > 0);
-      } else {
-        files = filesText.split("\n").map((line) => line.trim().replace(/^[-*]\s*/, "")).filter((line) => line.length > 0);
-      }
+      const files = parseFilesText(filesText);
       suggestedSplits.push({
         files,
         rationale: match[2].trim(),
@@ -2616,8 +2624,8 @@ async function runAgenticRelease(config) {
     explainWhenToUse: true,
     includeCategories: true
   });
-  const systemPrompt = buildSystemPrompt$1(toolGuidance);
-  const userMessage = buildUserMessage({
+  const systemPrompt = buildSystemPrompt$2(toolGuidance);
+  const userMessage = buildUserMessage$1({
     fromRef,
     toRef,
     logContent,
@@ -2658,7 +2666,7 @@ async function runAgenticRelease(config) {
     toolMetrics: result.toolMetrics
   };
 }
-function buildSystemPrompt$1(toolGuidance) {
+function buildSystemPrompt$2(toolGuidance) {
   return `You are a professional software engineer writing release notes for your team and users.
 
 ${toolGuidance}
@@ -2733,7 +2741,7 @@ RELEASE_NOTES:
 
 Output only the JSON. No conversational remarks or follow-up offers.`;
 }
-function buildUserMessage(params) {
+function buildUserMessage$1(params) {
   const { fromRef, toRef, logContent, diffContent, milestoneIssues, releaseFocus, userContext } = params;
   let message = `I need comprehensive release notes for changes from ${fromRef} to ${toRef}.
 
@@ -3272,7 +3280,7 @@ async function runAgenticPublish(config) {
   };
   const tools = createToolRegistry(toolContext);
   tools.registerAll(createPublishTools());
-  const systemPrompt = buildSystemPrompt(issue, dryRun);
+  const systemPrompt = buildSystemPrompt$1(issue, dryRun);
   const userPrompt = buildUserPrompt({
     issue,
     targetBranch,
@@ -3299,7 +3307,7 @@ async function runAgenticPublish(config) {
     storage,
     logger: logger2
   });
-  const analysis = parseAgentResponse(result.finalMessage);
+  const analysis = parseAgentResponse$1(result.finalMessage);
   return {
     success: analysis.success,
     message: result.finalMessage,
@@ -3310,7 +3318,7 @@ async function runAgenticPublish(config) {
     manualSteps: analysis.manualSteps
   };
 }
-function buildSystemPrompt(issue, dryRun) {
+function buildSystemPrompt$1(issue, dryRun) {
   const modeNote = dryRun ? "\n\nIMPORTANT: This is a DRY RUN. Do not use tools that make destructive changes (like reset_branch or sync_branch). Only use diagnostic tools to analyze the issue and provide recommendations." : "";
   return `You are an expert Git operations assistant helping to diagnose and fix issues that prevent publishing a software package.
 
@@ -3367,7 +3375,7 @@ Please investigate this issue and ${process.env.DRY_RUN ? "recommend how to fix
 
 If the issue requires manual intervention, please explain why and provide clear steps.`;
 }
-function parseAgentResponse(message) {
+function parseAgentResponse$1(message) {
   const successIndicators = [
     "successfully",
     "resolved",
@@ -3469,6 +3477,729 @@ function formatAgenticPublishResult(result) {
   lines.push("");
   return lines.join("\n");
 }
+function createDependencyTools() {
+  return [
+    createGetNpmPackageInfoTool(),
+    createCheckPeerDependenciesTool(),
+    createGetLatestVersionsTool(),
+    createAnalyzeVersionCompatibilityTool(),
+    createGetPackageChangelogTool(),
+    createSuggestVersionAlignmentTool()
+  ];
+}
+function createGetNpmPackageInfoTool() {
+  return {
+    name: "get_npm_package_info",
+    description: "Get detailed information about an npm package including latest version, description, peer dependencies, and recent versions. Use this to understand what version is available and what its requirements are.",
+    category: "Research",
+    cost: "moderate",
+    parameters: {
+      type: "object",
+      properties: {
+        packageName: {
+          type: "string",
+          description: 'The npm package name (e.g., "openai", "@riotprompt/riotprompt")'
+        }
+      },
+      required: ["packageName"]
+    },
+    examples: [
+      {
+        scenario: "Check latest version of openai package",
+        params: { packageName: "openai" },
+        expectedResult: '{ "name": "openai", "version": "6.16.0", "peerDependencies": { "zod": "^3.23.8" }, "versions": ["6.16.0", "6.15.0", ...] }'
+      }
+    ],
+    execute: async (params, _context) => {
+      const { packageName } = params;
+      try {
+        const { exec } = await import("child_process");
+        const { promisify } = await import("./__vite-browser-external-l0sNRNKZ.js");
+        const execAsync = promisify(exec);
+        const { stdout } = await execAsync(`npm view ${packageName} --json`, {
+          timeout: 3e4
+        });
+        const info = JSON.parse(stdout);
+        return {
+          name: info.name,
+          version: info.version,
+          description: info.description,
+          peerDependencies: info.peerDependencies || {},
+          peerDependenciesMeta: info.peerDependenciesMeta || {},
+          dependencies: Object.keys(info.dependencies || {}).length,
+          versions: (info.versions || []).slice(-10),
+          // Last 10 versions
+          repository: info.repository?.url || null,
+          homepage: info.homepage || null
+        };
+      } catch (error) {
+        return {
+          error: `Failed to get package info for ${packageName}: ${error.message}`
+        };
+      }
+    }
+  };
+}
+function createCheckPeerDependenciesTool() {
+  return {
+    name: "check_peer_dependencies",
+    description: "Check if a specific version of a package is compatible with another package based on peer dependency requirements. Use this to verify if updating one package would break compatibility with another.",
+    category: "Analysis",
+    cost: "moderate",
+    parameters: {
+      type: "object",
+      properties: {
+        packageName: {
+          type: "string",
+          description: "The package to check peer dependencies for"
+        },
+        packageVersion: {
+          type: "string",
+          description: "The version of the package to check"
+        },
+        dependencyName: {
+          type: "string",
+          description: "The dependency to check compatibility with"
+        },
+        dependencyVersion: {
+          type: "string",
+          description: "The version of the dependency currently installed"
+        }
+      },
+      required: ["packageName", "packageVersion", "dependencyName", "dependencyVersion"]
+    },
+    examples: [
+      {
+        scenario: "Check if @riotprompt/riotprompt@0.0.21 is compatible with openai@4.104.0",
+        params: {
+          packageName: "@riotprompt/riotprompt",
+          packageVersion: "0.0.21",
+          dependencyName: "openai",
+          dependencyVersion: "4.104.0"
+        },
+        expectedResult: '{ "compatible": false, "required": "^6.15.0", "current": "4.104.0", "recommendation": "Upgrade openai to ^6.15.0" }'
+      }
+    ],
+    execute: async (params) => {
+      const { packageName, packageVersion, dependencyName, dependencyVersion } = params;
+      try {
+        const { exec } = await import("child_process");
+        const { promisify } = await import("./__vite-browser-external-l0sNRNKZ.js");
+        const execAsync = promisify(exec);
+        const semver = await import("./index-Bim8aOsc.js").then((n) => n.i);
+        const { stdout } = await execAsync(`npm view ${packageName}@${packageVersion} peerDependencies peerDependenciesMeta --json`, {
+          timeout: 3e4
+        });
+        const info = JSON.parse(stdout);
+        const peerDeps = info.peerDependencies || info || {};
+        const peerDepsMeta = info.peerDependenciesMeta || {};
+        const requiredRange = peerDeps[dependencyName];
+        if (!requiredRange) {
+          return {
+            compatible: true,
+            reason: `${packageName}@${packageVersion} does not have a peer dependency on ${dependencyName}`
+          };
+        }
+        const isOptional = peerDepsMeta[dependencyName]?.optional === true;
+        const satisfies = semver.satisfies(dependencyVersion, requiredRange);
+        return {
+          compatible: satisfies,
+          required: requiredRange,
+          current: dependencyVersion,
+          optional: isOptional,
+          recommendation: satisfies ? "Current version is compatible" : `${isOptional ? "(Optional) " : ""}Update ${dependencyName} to ${requiredRange} to satisfy peer dependency`
+        };
+      } catch (error) {
+        return {
+          error: `Failed to check peer dependencies: ${error.message}`
+        };
+      }
+    }
+  };
+}
+function createGetLatestVersionsTool() {
+  return {
+    name: "get_latest_versions",
+    description: "Get the latest versions of multiple npm packages at once. Use this to quickly check if packages are outdated.",
+    category: "Research",
+    cost: "moderate",
+    parameters: {
+      type: "object",
+      properties: {
+        packages: {
+          type: "array",
+          description: "Array of package names to check",
+          items: {
+            type: "string",
+            description: "Package name"
+          }
+        }
+      },
+      required: ["packages"]
+    },
+    examples: [
+      {
+        scenario: "Check latest versions of openai and zod",
+        params: { packages: ["openai", "zod"] },
+        expectedResult: '{ "openai": "6.16.0", "zod": "3.25.76" }'
+      }
+    ],
+    execute: async (params) => {
+      const { packages } = params;
+      const results = {};
+      const { exec } = await import("child_process");
+      const { promisify } = await import("./__vite-browser-external-l0sNRNKZ.js");
+      const execAsync = promisify(exec);
+      const batchSize = 5;
+      for (let i = 0; i < packages.length; i += batchSize) {
+        const batch = packages.slice(i, i + batchSize);
+        await Promise.all(
+          batch.map(async (pkg) => {
+            try {
+              const { stdout } = await execAsync(`npm view ${pkg} version`, {
+                timeout: 15e3
+              });
+              results[pkg] = stdout.trim();
+            } catch (error) {
+              results[pkg] = { error: error.message };
+            }
+          })
+        );
+      }
+      return results;
+    }
+  };
+}
+function createAnalyzeVersionCompatibilityTool() {
+  return {
+    name: "analyze_version_compatibility",
+    description: "Analyze if a target version of a package is compatible with the current project setup by checking all peer dependencies recursively. Use this before recommending an upgrade.",
+    category: "Analysis",
+    cost: "expensive",
+    parameters: {
+      type: "object",
+      properties: {
+        packageName: {
+          type: "string",
+          description: "The package to analyze upgrading to"
+        },
+        targetVersion: {
+          type: "string",
+          description: "The target version to upgrade to"
+        },
+        currentDependencies: {
+          type: "object",
+          description: "Current dependencies and their versions (as key-value pairs)"
+        }
+      },
+      required: ["packageName", "targetVersion", "currentDependencies"]
+    },
+    execute: async (params) => {
+      const { packageName, targetVersion, currentDependencies } = params;
+      try {
+        const { exec } = await import("child_process");
+        const { promisify } = await import("./__vite-browser-external-l0sNRNKZ.js");
+        const execAsync = promisify(exec);
+        const semver = await import("./index-Bim8aOsc.js").then((n) => n.i);
+        const { stdout } = await execAsync(`npm view ${packageName}@${targetVersion} peerDependencies peerDependenciesMeta --json`, {
+          timeout: 3e4
+        });
+        const info = JSON.parse(stdout);
+        const peerDeps = info.peerDependencies || info || {};
+        const peerDepsMeta = info.peerDependenciesMeta || {};
+        const conflicts = [];
+        const compatible = [];
+        for (const [dep, requiredRange] of Object.entries(peerDeps)) {
+          const currentVersion = currentDependencies[dep];
+          const isOptional = peerDepsMeta[dep]?.optional === true;
+          if (!currentVersion) {
+            if (!isOptional) {
+              conflicts.push({
+                dependency: dep,
+                required: requiredRange,
+                current: "not installed",
+                optional: false
+              });
+            }
+            continue;
+          }
+          const cleanCurrent = currentVersion.replace(/^[\^~]/, "");
+          const satisfies = semver.satisfies(cleanCurrent, requiredRange);
+          if (satisfies) {
+            compatible.push({
+              dependency: dep,
+              required: requiredRange,
+              current: currentVersion
+            });
+          } else {
+            conflicts.push({
+              dependency: dep,
+              required: requiredRange,
+              current: currentVersion,
+              optional: isOptional
+            });
+          }
+        }
+        return {
+          canUpgrade: conflicts.filter((c) => !c.optional).length === 0,
+          packageName,
+          targetVersion,
+          conflicts,
+          compatible,
+          summary: conflicts.length === 0 ? `Safe to upgrade ${packageName} to ${targetVersion}` : `Upgrading ${packageName} to ${targetVersion} requires updating: ${conflicts.map((c) => `${c.dependency} to ${c.required}`).join(", ")}`
+        };
+      } catch (error) {
+        return {
+          error: `Failed to analyze compatibility: ${error.message}`
+        };
+      }
+    }
+  };
+}
+function createGetPackageChangelogTool() {
+  return {
+    name: "get_package_changelog",
+    description: "Get recent release notes or changelog information for a package to understand what changed between versions. Use this when evaluating whether to upgrade.",
+    category: "Research",
+    cost: "moderate",
+    parameters: {
+      type: "object",
+      properties: {
+        packageName: {
+          type: "string",
+          description: "The npm package name"
+        },
+        fromVersion: {
+          type: "string",
+          description: "The version to compare from (optional)"
+        },
+        toVersion: {
+          type: "string",
+          description: "The version to compare to (optional, defaults to latest)"
+        }
+      },
+      required: ["packageName"]
+    },
+    execute: async (params) => {
+      const { packageName, fromVersion } = params;
+      try {
+        const { exec } = await import("child_process");
+        const { promisify } = await import("./__vite-browser-external-l0sNRNKZ.js");
+        const execAsync = promisify(exec);
+        const { stdout: infoJson } = await execAsync(`npm view ${packageName} repository.url homepage --json`, {
+          timeout: 15e3
+        });
+        const info = JSON.parse(infoJson);
+        const repoUrl = info["repository.url"] || info.repository?.url || "";
+        const homepage = info.homepage || "";
+        const { stdout: versionsJson } = await execAsync(`npm view ${packageName} time --json`, {
+          timeout: 15e3
+        });
+        const times = JSON.parse(versionsJson);
+        const versions = Object.entries(times).filter(([v]) => v !== "created" && v !== "modified").map(([version, time]) => ({ version, time })).sort((a, b) => new Date(b.time).getTime() - new Date(a.time).getTime()).slice(0, 10);
+        let releasesUrl = "";
+        const match = repoUrl.match(/github\.com[/:]([^/]+\/[^/.]+)/);
+        if (match) {
+          releasesUrl = `https://github.com/${match[1]}/releases`;
+        }
+        return {
+          packageName,
+          currentVersion: fromVersion || "unknown",
+          latestVersion: versions[0]?.version || "unknown",
+          recentVersions: versions,
+          releasesUrl: releasesUrl || "Unable to determine releases URL",
+          homepage,
+          note: "Check the releases URL for detailed changelog information"
+        };
+      } catch (error) {
+        return {
+          error: `Failed to get changelog info: ${error.message}`
+        };
+      }
+    }
+  };
+}
+function createSuggestVersionAlignmentTool() {
+  return {
+    name: "suggest_version_alignment",
+    description: "Given a list of packages with version conflicts, suggest which versions to align on and in what order to update them. Use this to create a coherent upgrade plan.",
+    category: "Planning",
+    cost: "cheap",
+    parameters: {
+      type: "object",
+      properties: {
+        conflicts: {
+          type: "array",
+          description: "Array of version conflicts",
+          items: {
+            type: "object",
+            description: "A version conflict entry",
+            properties: {
+              packageName: { type: "string", description: "Package name" },
+              versions: {
+                type: "array",
+                description: "Different versions in use",
+                items: { type: "string", description: "Version string" }
+              },
+              usedBy: {
+                type: "array",
+                description: "Which projects use each version",
+                items: { type: "string", description: "Project name" }
+              }
+            }
+          }
+        },
+        strategy: {
+          type: "string",
+          description: 'Alignment strategy: "latest" (prefer latest), "conservative" (prefer most common), "compatible" (prefer most compatible)',
+          enum: ["latest", "conservative", "compatible"]
+        }
+      },
+      required: ["conflicts", "strategy"]
+    },
+    execute: async (params) => {
+      const { conflicts, strategy } = params;
+      const semver = await import("./index-Bim8aOsc.js").then((n) => n.i);
+      const recommendations = [];
+      for (const conflict of conflicts) {
+        const { packageName, versions } = conflict;
+        const sortedVersions = [...versions].map((v) => v.replace(/^[\^~]/, "")).filter((v) => semver.valid(v)).sort((a, b) => semver.compare(b, a));
+        let recommendedVersion;
+        let reason;
+        switch (strategy) {
+          case "latest":
+            recommendedVersion = `^${sortedVersions[0]}`;
+            reason = "Using latest version for newest features and security fixes";
+            break;
+          case "conservative": {
+            const versionCounts = /* @__PURE__ */ new Map();
+            for (const v of versions) {
+              const clean = v.replace(/^[\^~]/, "");
+              versionCounts.set(clean, (versionCounts.get(clean) || 0) + 1);
+            }
+            const mostCommon = [...versionCounts.entries()].sort((a, b) => b[1] - a[1])[0];
+            recommendedVersion = `^${mostCommon[0]}`;
+            reason = `Most commonly used version (${mostCommon[1]} packages)`;
+            break;
+          }
+          case "compatible":
+          default:
+            recommendedVersion = `^${sortedVersions[sortedVersions.length - 1]}`;
+            reason = "Lowest common version for maximum compatibility";
+            break;
+        }
+        recommendations.push({
+          packageName,
+          currentVersions: versions,
+          recommendedVersion,
+          reason,
+          updateOrder: recommendations.length + 1
+        });
+      }
+      return {
+        strategy,
+        recommendations,
+        summary: `Analyzed ${conflicts.length} packages with version conflicts. Strategy: ${strategy}`
+      };
+    }
+  };
+}
+async function runAgenticDependencyAnalysis(config) {
+  const {
+    reportData,
+    strategy = "latest",
+    focusPackages,
+    model = "gpt-4o",
+    maxIterations = 15,
+    debug = false,
+    debugRequestFile,
+    debugResponseFile,
+    storage,
+    logger: logger2,
+    openaiReasoning
+  } = config;
+  const toolRegistry = createToolRegistry({
+    workingDirectory: process.cwd(),
+    storage,
+    logger: logger2
+  });
+  const tools = createDependencyTools();
+  toolRegistry.registerAll(tools);
+  const toolGuidance = generateToolGuidance(tools, {
+    strategy: "adaptive",
+    includeExamples: true,
+    explainWhenToUse: true,
+    includeCategories: true
+  });
+  const systemPrompt = buildSystemPrompt(strategy, toolGuidance);
+  const userMessage = buildUserMessage(reportData, strategy, focusPackages);
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: userMessage }
+  ];
+  const agenticConfig = {
+    messages,
+    tools: toolRegistry,
+    model,
+    maxIterations,
+    debug,
+    debugRequestFile,
+    debugResponseFile,
+    storage,
+    logger: logger2,
+    openaiReasoning,
+    tokenBudget: {
+      max: 1e5,
+      reserveForResponse: 4e3,
+      strategy: "fifo",
+      onBudgetExceeded: "compress"
+    }
+  };
+  const result = await runAgentic(agenticConfig);
+  const analysis = parseAgentResponse(result.finalMessage, reportData);
+  return {
+    recommendations: analysis.recommendations,
+    summary: analysis.summary,
+    upgradeOrder: analysis.upgradeOrder,
+    warnings: analysis.warnings,
+    iterations: result.iterations,
+    toolCallsExecuted: result.toolCallsExecuted,
+    conversationHistory: result.conversationHistory,
+    toolMetrics: result.toolMetrics
+  };
+}
+function buildSystemPrompt(strategy, toolGuidance) {
+  return `You are an expert dependency management advisor for JavaScript/TypeScript monorepos.
+
+Your goal is to analyze dependency conflicts and version inconsistencies across a monorepo and provide actionable recommendations for version alignment and upgrades.
+
+## Your Strategy: ${strategy.toUpperCase()}
+
+${strategy === "latest" ? `
+- Prioritize upgrading to the latest stable versions
+- Security and new features are important
+- Breaking changes are acceptable if the benefits outweigh the migration cost
+` : strategy === "conservative" ? `
+- Prefer the most commonly used version across projects
+- Minimize disruption to the codebase
+- Only recommend upgrades when there's a clear benefit
+` : `
+- Find versions that work for all packages
+- Prioritize compatibility over new features
+- Recommend the minimum viable upgrade
+`}
+
+## Analysis Process
+
+1. **Review Conflicts**: Examine each version conflict in the report
+2. **Research Packages**: Use tools to look up package information and peer dependencies
+3. **Check Compatibility**: Verify that recommended versions are compatible
+4. **Create Upgrade Plan**: Determine the order in which packages should be updated
+5. **Identify Breaking Changes**: Flag any upgrades that might require code changes
+
+## Tools Available
+
+${toolGuidance}
+
+## Output Format
+
+After your analysis, provide recommendations in this format:
+
+### SUMMARY
+A brief overview of the analysis findings.
+
+### RECOMMENDATIONS
+For each recommendation:
+- **Package**: package name
+- **Current**: list of current versions in use
+- **Recommended**: the version to align on
+- **Priority**: high/medium/low
+- **Reason**: why this upgrade is recommended
+- **Breaking Changes**: yes/no and what to watch for
+- **Affected Projects**: which projects need to be updated
+
+### UPGRADE ORDER
+List the packages in the order they should be upgraded (dependencies first).
+
+### WARNINGS
+Any concerns or things to watch out for.
+
+Be thorough but concise. Focus on the most impactful changes first.`;
+}
+function buildUserMessage(reportData, strategy, focusPackages) {
+  const conflictsSummary = reportData.conflicts.map((c) => {
+    const usageInfo = c.usages.map((u) => `${u.version} (used by: ${u.usedBy.join(", ")})`).join("\n    - ");
+    return `  - ${c.packageName}:
+    - ${usageInfo}`;
+  }).join("\n");
+  const sharedSummary = reportData.sharedDependencies.slice(0, 20).map((s) => `  - ${s.name}: ${s.versions.join(" | ")} (${s.packageCount} packages)`).join("\n");
+  const packagesSummary = reportData.packageSummaries.map((p) => `  - ${p.name}: ${p.deps} deps, ${p.devDeps} devDeps, ${p.total} total`).join("\n");
+  let focusNote = "";
+  if (focusPackages && focusPackages.length > 0) {
+    focusNote = `
+
+**FOCUS**: Please pay special attention to these packages: ${focusPackages.join(", ")}`;
+  }
+  return `Please analyze the following dependency report and provide upgrade recommendations using the "${strategy}" strategy.
+
+## Dependency Report Summary
+
+- **Packages in monorepo**: ${reportData.packageCount}
+- **Total dependencies**: ${reportData.totalDependencies}
+- **Unique dependencies**: ${reportData.uniqueDependencies}
+- **Version conflicts**: ${reportData.conflictCount}
+
+## Version Conflicts (${reportData.conflictCount} packages)
+
+${conflictsSummary || "No version conflicts found."}
+
+## Most Shared Dependencies (top 20)
+
+${sharedSummary}
+
+## Package Summary
+
+${packagesSummary}
+${focusNote}
+
+Please use the available tools to research these packages, check their peer dependencies, and provide a comprehensive upgrade plan.`;
+}
+function parseAgentResponse(response, reportData) {
+  const recommendations = [];
+  const warnings = [];
+  let summary = "";
+  let upgradeOrder = [];
+  const summaryMatch = response.match(/###\s*SUMMARY\s*\n([\s\S]*?)(?=###|$)/i);
+  if (summaryMatch) {
+    summary = summaryMatch[1].trim();
+  }
+  const recsMatch = response.match(/###\s*RECOMMENDATIONS?\s*\n([\s\S]*?)(?=###|$)/i);
+  if (recsMatch) {
+    const recsText = recsMatch[1];
+    const recBlocks = recsText.split(/\n(?=\*\*Package\*\*:|\d+\.\s+\*\*)/);
+    let order = 1;
+    for (const block of recBlocks) {
+      if (!block.trim()) continue;
+      const packageMatch = block.match(/\*\*Package\*\*:\s*([^\n]+)/i);
+      const currentMatch = block.match(/\*\*Current\*\*:\s*([^\n]+)/i);
+      const recommendedMatch = block.match(/\*\*Recommended\*\*:\s*([^\n]+)/i);
+      const priorityMatch = block.match(/\*\*Priority\*\*:\s*(high|medium|low)/i);
+      const reasonMatch = block.match(/\*\*Reason\*\*:\s*([^\n]+)/i);
+      const breakingMatch = block.match(/\*\*Breaking\s*Changes?\*\*:\s*([^\n]+)/i);
+      const affectedMatch = block.match(/\*\*Affected\s*Projects?\*\*:\s*([^\n]+)/i);
+      if (packageMatch) {
+        recommendations.push({
+          packageName: packageMatch[1].trim(),
+          currentVersions: currentMatch ? currentMatch[1].split(/[,|]/).map((v) => v.trim()) : [],
+          recommendedVersion: recommendedMatch ? recommendedMatch[1].trim() : "unknown",
+          priority: priorityMatch ? priorityMatch[1].toLowerCase() : "medium",
+          reason: reasonMatch ? reasonMatch[1].trim() : "",
+          updateOrder: order++,
+          affectedProjects: affectedMatch ? affectedMatch[1].split(/[,|]/).map((p) => p.trim()) : [],
+          breakingChanges: breakingMatch ? breakingMatch[1].toLowerCase().includes("yes") : false
+        });
+      }
+    }
+  }
+  const orderMatch = response.match(/###\s*UPGRADE\s*ORDER\s*\n([\s\S]*?)(?=###|$)/i);
+  if (orderMatch) {
+    const orderText = orderMatch[1];
+    upgradeOrder = orderText.split("\n").filter((line) => line.trim()).map((line) => line.replace(/^[\d.*-]+\s*/, "").trim()).filter(Boolean);
+  }
+  const warningsMatch = response.match(/###\s*WARNINGS?\s*\n([\s\S]*?)(?=###|$)/i);
+  if (warningsMatch) {
+    const warningsText = warningsMatch[1];
+    warnings.push(
+      ...warningsText.split("\n").filter((line) => line.trim()).map((line) => line.replace(/^[-*]+\s*/, "").trim()).filter(Boolean)
+    );
+  }
+  if (recommendations.length === 0 && reportData.conflicts.length > 0) {
+    for (const conflict of reportData.conflicts.slice(0, 10)) {
+      recommendations.push({
+        packageName: conflict.packageName,
+        currentVersions: conflict.versions,
+        recommendedVersion: "See analysis",
+        priority: "medium",
+        reason: "Version conflict detected - manual review recommended",
+        updateOrder: recommendations.length + 1,
+        affectedProjects: conflict.usages.flatMap((u) => u.usedBy),
+        breakingChanges: false
+      });
+    }
+    summary = response.slice(0, 500) + "...";
+  }
+  return {
+    recommendations,
+    summary: summary || "Analysis complete. See recommendations below.",
+    upgradeOrder,
+    warnings
+  };
+}
+function formatDependencyAnalysisReport(result) {
+  const lines = [];
+  lines.push("");
+  lines.push("╔═══════════════════════════════════════════════════════════════════╗");
+  lines.push("║           🤖 AI DEPENDENCY ANALYSIS REPORT                        ║");
+  lines.push("╚═══════════════════════════════════════════════════════════════════╝");
+  lines.push("");
+  lines.push(`📊 Analysis completed in ${result.iterations} iterations with ${result.toolCallsExecuted} tool calls`);
+  lines.push("");
+  lines.push("┌─ 📝 SUMMARY");
+  lines.push("│");
+  const summaryLines = result.summary.split("\n");
+  for (const line of summaryLines) {
+    lines.push(`│  ${line}`);
+  }
+  lines.push("");
+  if (result.recommendations.length > 0) {
+    lines.push("┌─ 💡 RECOMMENDATIONS");
+    lines.push("│");
+    const priorityOrder = { high: 0, medium: 1, low: 2 };
+    const sortedRecs = [...result.recommendations].sort((a, b) => {
+      const pDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+      return pDiff !== 0 ? pDiff : a.updateOrder - b.updateOrder;
+    });
+    for (let i = 0; i < sortedRecs.length; i++) {
+      const rec = sortedRecs[i];
+      const isLast = i === sortedRecs.length - 1;
+      const priorityIcon = rec.priority === "high" ? "🔴" : rec.priority === "medium" ? "🟡" : "🟢";
+      const breakingIcon = rec.breakingChanges ? " ⚠️" : "";
+      lines.push(`│  ${isLast ? "└─" : "├─"} ${priorityIcon} ${rec.packageName}${breakingIcon}`);
+      lines.push(`│  ${isLast ? "  " : "│ "}    Current: ${rec.currentVersions.join(", ")}`);
+      lines.push(`│  ${isLast ? "  " : "│ "}    Recommended: ${rec.recommendedVersion}`);
+      lines.push(`│  ${isLast ? "  " : "│ "}    Reason: ${rec.reason}`);
+      if (rec.affectedProjects.length > 0) {
+        lines.push(`│  ${isLast ? "  " : "│ "}    Affects: ${rec.affectedProjects.slice(0, 5).join(", ")}${rec.affectedProjects.length > 5 ? ` +${rec.affectedProjects.length - 5} more` : ""}`);
+      }
+    }
+    lines.push("");
+  }
+  if (result.upgradeOrder.length > 0) {
+    lines.push("┌─ 📋 UPGRADE ORDER");
+    lines.push("│");
+    for (let i = 0; i < result.upgradeOrder.length; i++) {
+      const pkg = result.upgradeOrder[i];
+      const isLast = i === result.upgradeOrder.length - 1;
+      lines.push(`│  ${isLast ? "└─" : "├─"} ${i + 1}. ${pkg}`);
+    }
+    lines.push("");
+  }
+  if (result.warnings.length > 0) {
+    lines.push("┌─ ⚠️  WARNINGS");
+    lines.push("│");
+    for (let i = 0; i < result.warnings.length; i++) {
+      const warning = result.warnings[i];
+      const isLast = i === result.warnings.length - 1;
+      lines.push(`│  ${isLast ? "└─" : "├─"} ${warning}`);
+    }
+    lines.push("");
+  }
+  lines.push("╔═══════════════════════════════════════════════════════════════════╗");
+  lines.push("║                    END OF AI ANALYSIS                             ║");
+  lines.push("╚═══════════════════════════════════════════════════════════════════╝");
+  lines.push("");
+  return lines.join("\n");
+}
 function createConversationLogger(config) {
   const {
     outputDir,
@@ -3875,6 +4606,7 @@ export {
   createCompletion,
   createCompletionWithRetry,
   createConversationLogger,
+  createDependencyTools,
   createMetricsCollector,
   createNoOpLogger,
   createPublishTools,
@@ -3885,6 +4617,7 @@ export {
   createToolRegistry,
   editContentInEditor,
   formatAgenticPublishResult,
+  formatDependencyAnalysisReport,
   generateConversationId,
   generateReflectionReport,
   getLLMFeedbackInEditor,
@@ -3899,6 +4632,7 @@ export {
   requireTTY,
   runAgentic,
   runAgenticCommit,
+  runAgenticDependencyAnalysis,
   runAgenticPublish,
   runAgenticRelease,
   saveReflectionReport,