@chappibunny/repolens 1.4.0 → 1.5.1

package/src/ai/provider.js

@@ -6,7 +6,7 @@ import { executeAIRequest } from "../utils/rate-limit.js";
 const DEFAULT_TIMEOUT_MS = 60000;
 const DEFAULT_MAX_TOKENS = 2500;
 
-export async function generateText({ system, user, temperature, maxTokens, config }) {
+export async function generateText({ system, user, temperature, maxTokens, config, jsonMode, jsonSchema }) {
   // Check if AI is enabled (env var takes precedence, then config)
   const aiConfig = config?.ai || {};
   const enabled = process.env.REPOLENS_AI_ENABLED === "true" || aiConfig.enabled === true;
@@ -43,18 +43,58 @@ export async function generateText({ system, user, temperature, maxTokens, confi
   if (!baseUrl && provider === "openai_compatible") {
     warn("REPOLENS_AI_BASE_URL not set. Using OpenAI default.");
   }
+
+  // Select provider adapter
+  const adapter = getProviderAdapter(provider);
   
   try {
-    const result = await callOpenAICompatibleAPI({
-      baseUrl: baseUrl || "https://api.openai.com/v1",
+    const result = await adapter({
+      baseUrl: baseUrl || getDefaultBaseUrl(provider),
       apiKey,
       model,
       system,
       user,
       temperature: resolvedTemp,
       maxTokens: resolvedMaxTokens,
-      timeoutMs
+      timeoutMs,
+      jsonMode,
     });
+
+    // Validate JSON schema if provided
+    if (jsonMode && jsonSchema && result) {
+      const parsed = safeParseJSON(result);
+      if (!parsed) {
+        warn("AI returned invalid JSON, re-prompting once...");
+        const retryResult = await adapter({
+          baseUrl: baseUrl || getDefaultBaseUrl(provider),
+          apiKey,
+          model,
+          system,
+          user: user + "\n\nIMPORTANT: Your previous response was not valid JSON. Respond ONLY with a valid JSON object.",
+          temperature: resolvedTemp,
+          maxTokens: resolvedMaxTokens,
+          timeoutMs,
+          jsonMode,
+        });
+        const retryParsed = safeParseJSON(retryResult);
+        if (!retryParsed) {
+          warn("AI JSON re-prompt also failed, falling back to deterministic.");
+          return { success: false, error: "Invalid JSON from AI after retry", fallback: true };
+        }
+        const schemaError = validateSchema(retryParsed, jsonSchema);
+        if (schemaError) {
+          warn(`AI JSON schema mismatch after retry: ${schemaError}`);
+          return { success: false, error: schemaError, fallback: true };
+        }
+        return { success: true, text: retryResult, parsed: retryParsed, fallback: false };
+      }
+      const schemaError = validateSchema(parsed, jsonSchema);
+      if (schemaError) {
+        warn(`AI JSON schema mismatch: ${schemaError}`);
+        return { success: false, error: schemaError, fallback: true };
+      }
+      return { success: true, text: result, parsed, fallback: false };
+    }
     
     return {
       success: true,
@@ -72,7 +112,59 @@ export async function generateText({ system, user, temperature, maxTokens, confi
   }
 }
 
-async function callOpenAICompatibleAPI({ baseUrl, apiKey, model, system, user, temperature, maxTokens, timeoutMs }) {
+/**
+ * Parse JSON safely, returning null on failure.
+ */
+function safeParseJSON(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    // Try extracting JSON from markdown code blocks
+    const match = text?.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (match) {
+      try { return JSON.parse(match[1].trim()); } catch { /* fall through */ }
+    }
+    return null;
+  }
+}
+
+/**
+ * Validate an object against a simple schema (required string fields).
+ * Returns error message or null if valid.
+ */
+function validateSchema(obj, schema) {
+  if (!schema || !schema.required) return null;
+  for (const field of schema.required) {
+    if (!(field in obj)) return `Missing required field: ${field}`;
+  }
+  return null;
+}
+
+/**
+ * Get default base URL for a provider.
+ */
+function getDefaultBaseUrl(provider) {
+  switch (provider) {
+    case "anthropic": return "https://api.anthropic.com";
+    case "azure": return process.env.REPOLENS_AI_BASE_URL || "https://api.openai.com/v1";
+    case "google": return "https://generativelanguage.googleapis.com";
+    default: return "https://api.openai.com/v1";
+  }
+}
+
+/**
+ * Select the appropriate provider adapter function.
+ */
+function getProviderAdapter(provider) {
+  switch (provider) {
+    case "anthropic": return callAnthropicAPI;
+    case "google": return callGoogleAPI;
+    // "openai_compatible" and "azure" both use the OpenAI format
+    default: return callOpenAICompatibleAPI;
+  }
+}
+
+async function callOpenAICompatibleAPI({ baseUrl, apiKey, model, system, user, temperature, maxTokens, timeoutMs, jsonMode }) {
   return await executeAIRequest(async () => {
     const url = `${baseUrl}/chat/completions`;
     
@@ -94,6 +186,9 @@ async function callOpenAICompatibleAPI({ baseUrl, apiKey, model, system, user, t
       if (temperature != null) {
         body.temperature = temperature;
       }
+      if (jsonMode) {
+        body.response_format = { type: "json_object" };
+      }
 
       const response = await fetch(url, {
         method: "POST",
@@ -132,15 +227,126 @@ async function callOpenAICompatibleAPI({ baseUrl, apiKey, model, system, user, t
   });
 }
 
+/**
+ * Anthropic Messages API adapter.
+ */
+async function callAnthropicAPI({ baseUrl, apiKey, model, system, user, temperature, maxTokens, timeoutMs }) {
+  return await executeAIRequest(async () => {
+    const url = `${baseUrl}/v1/messages`;
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+    try {
+      const body = {
+        model: model || "claude-sonnet-4-20250514",
+        max_tokens: maxTokens,
+        system,
+        messages: [{ role: "user", content: user }],
+      };
+      if (temperature != null) {
+        body.temperature = temperature;
+      }
+
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01",
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Anthropic API error (${response.status}): ${errorText}`);
+      }
+
+      const data = await response.json();
+
+      if (!data.content || data.content.length === 0) {
+        throw new Error("No content returned from Anthropic API");
+      }
+
+      return data.content[0].text;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        throw new Error(`Request timeout after ${timeoutMs}ms`);
+      }
+      throw error;
+    }
+  });
+}
+
+/**
+ * Google Gemini API adapter.
+ */
+async function callGoogleAPI({ baseUrl, apiKey, model, system, user, temperature, maxTokens, timeoutMs }) {
+  return await executeAIRequest(async () => {
+    const geminiModel = model || "gemini-pro";
+    const url = `${baseUrl}/v1beta/models/${geminiModel}:generateContent?key=${encodeURIComponent(apiKey)}`;
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+    try {
+      const body = {
+        contents: [{ parts: [{ text: `${system}\n\n${user}` }] }],
+        generationConfig: { maxOutputTokens: maxTokens },
+      };
+      if (temperature != null) {
+        body.generationConfig.temperature = temperature;
+      }
+
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Google API error (${response.status}): ${errorText}`);
+      }
+
+      const data = await response.json();
+
+      if (!data.candidates || data.candidates.length === 0) {
+        throw new Error("No candidates returned from Google API");
+      }
+
+      return data.candidates[0].content.parts[0].text;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        throw new Error(`Request timeout after ${timeoutMs}ms`);
+      }
+      throw error;
+    }
+  });
+}
+
 export function isAIEnabled() {
   return process.env.REPOLENS_AI_ENABLED === "true";
 }
 
 export function getAIConfig() {
+  const provider = process.env.REPOLENS_AI_PROVIDER || "openai_compatible";
+  const defaultModel = provider === "anthropic" ? "claude-sonnet-4-20250514"
+    : provider === "google" ? "gemini-pro"
+    : "gpt-5-mini";
   return {
     enabled: isAIEnabled(),
-    provider: process.env.REPOLENS_AI_PROVIDER || "openai_compatible",
-    model: process.env.REPOLENS_AI_MODEL || "gpt-5-mini",
+    provider,
+    model: process.env.REPOLENS_AI_MODEL || defaultModel,
     hasApiKey: !!process.env.REPOLENS_AI_API_KEY,
     temperature: process.env.REPOLENS_AI_TEMPERATURE ? parseFloat(process.env.REPOLENS_AI_TEMPERATURE) : undefined,
     maxTokens: parseInt(process.env.REPOLENS_AI_MAX_TOKENS || DEFAULT_MAX_TOKENS)

package/src/analyzers/codeowners.js

@@ -0,0 +1,146 @@
+// CODEOWNERS file parser
+// Maps file paths to team/individual owners
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { info } from "../utils/logger.js";
+
+/**
+ * Parse CODEOWNERS file and return ownership rules.
+ * Searches standard locations: CODEOWNERS, .github/CODEOWNERS, docs/CODEOWNERS
+ */
+export async function parseCodeowners(repoRoot) {
+  const locations = [
+    path.join(repoRoot, "CODEOWNERS"),
+    path.join(repoRoot, ".github", "CODEOWNERS"),
+    path.join(repoRoot, "docs", "CODEOWNERS"),
+  ];
+
+  for (const loc of locations) {
+    try {
+      const content = await fs.readFile(loc, "utf8");
+      const rules = parseRules(content);
+      if (rules.length > 0) {
+        info(`CODEOWNERS loaded from ${path.relative(repoRoot, loc)} (${rules.length} rules)`);
+        return { found: true, file: path.relative(repoRoot, loc), rules };
+      }
+    } catch {
+      // File doesn't exist, try next
+    }
+  }
+
+  return { found: false, file: null, rules: [] };
+}
+
+/**
+ * Parse CODEOWNERS content into pattern→owners rules.
+ */
+function parseRules(content) {
+  const rules = [];
+
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+
+    const parts = trimmed.split(/\s+/);
+    if (parts.length < 2) continue;
+
+    const pattern = parts[0];
+    const owners = parts.slice(1).filter(o => o.startsWith("@") || o.includes("@"));
+
+    if (owners.length > 0) {
+      rules.push({ pattern, owners });
+    }
+  }
+
+  return rules;
+}
+
+/**
+ * Find owners for a given file path using CODEOWNERS rules.
+ * Rules are matched last-match-wins (same as GitHub behavior).
+ */
+export function findOwners(filePath, rules) {
+  let matched = [];
+
+  for (const rule of rules) {
+    if (matchPattern(filePath, rule.pattern)) {
+      matched = rule.owners;
+    }
+  }
+
+  return matched;
+}
+
+/**
+ * Match a file path against a CODEOWNERS pattern.
+ * Supports: *, **, directory patterns, exact matches.
+ */
+function matchPattern(filePath, pattern) {
+  const normalized = filePath.replace(/\\/g, "/");
+
+  // Remove leading slash for consistency
+  const cleanPattern = pattern.startsWith("/") ? pattern.slice(1) : pattern;
+
+  // Directory pattern (e.g., "src/")
+  if (cleanPattern.endsWith("/")) {
+    return normalized.startsWith(cleanPattern) || normalized.includes(`/${cleanPattern}`);
+  }
+
+  // Convert glob to regex
+  let regex = cleanPattern
+    .replace(/\./g, "\\.")
+    .replace(/\*\*/g, "<<DOUBLESTAR>>")
+    .replace(/\*/g, "[^/]*")
+    .replace(/<<DOUBLESTAR>>/g, ".*");
+
+  // If pattern has no path separator, match anywhere in path
+  if (!cleanPattern.includes("/")) {
+    regex = `(^|/)${regex}($|/)`;
+  } else {
+    regex = `(^|/)${regex}$`;
+  }
+
+  try {
+    return new RegExp(regex).test(normalized);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Build an ownership summary for modules.
+ * Returns a map of modulePath → owners[].
+ */
+export function buildOwnershipMap(modules, files, rules) {
+  if (!rules || rules.length === 0) return {};
+
+  const ownershipMap = {};
+
+  for (const mod of modules) {
+    const moduleFiles = files.filter(f => {
+      const normalized = f.replace(/\\/g, "/");
+      return normalized.startsWith(mod.key + "/") || normalized === mod.key;
+    });
+
+    // Find owners for representative files in this module
+    const ownerCounts = {};
+    for (const file of moduleFiles) {
+      const owners = findOwners(file, rules);
+      for (const owner of owners) {
+        ownerCounts[owner] = (ownerCounts[owner] || 0) + 1;
+      }
+    }
+
+    // Primary owners are those who own the most files in this module
+    const sortedOwners = Object.entries(ownerCounts)
+      .sort((a, b) => b[1] - a[1])
+      .map(([owner]) => owner);
+
+    if (sortedOwners.length > 0) {
+      ownershipMap[mod.key] = sortedOwners;
+    }
+  }
+
+  return ownershipMap;
+}

package/src/analyzers/context-builder.js

@@ -80,7 +80,17 @@ export function buildAIContext(scanResult, config) {
     
     patterns,
     
-    repoRoots: config.module_roots || []
+    repoRoots: config.module_roots || [],
+
+    // Monorepo workspace metadata (if detected)
+    monorepo: scanResult.monorepo?.isMonorepo ? {
+      tool: scanResult.monorepo.tool,
+      packageCount: scanResult.monorepo.packages.length,
+      packages: scanResult.monorepo.packages.slice(0, 20).map(p => ({
+        name: p.name,
+        path: p.path,
+      })),
+    } : undefined,
   };
 }
 

package/src/analyzers/monorepo-detector.js

@@ -0,0 +1,155 @@
+// Monorepo workspace detection
+// Detects npm/yarn workspaces, pnpm workspaces, and Lerna configurations
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { info } from "../utils/logger.js";
+
+/**
+ * Detect monorepo workspaces in a repository.
+ * Returns { isMonorepo, tool, packages[] } where each package has { name, path, packageJson }.
+ */
+export async function detectMonorepo(repoRoot) {
+  const result = { isMonorepo: false, tool: null, packages: [] };
+
+  // 1. Check package.json workspaces (npm/yarn)
+  const npmWorkspaces = await detectNpmWorkspaces(repoRoot);
+  if (npmWorkspaces.length > 0) {
+    result.isMonorepo = true;
+    result.tool = "npm/yarn workspaces";
+    result.packages = npmWorkspaces;
+    info(`Monorepo detected: ${result.tool} with ${result.packages.length} packages`);
+    return result;
+  }
+
+  // 2. Check pnpm-workspace.yaml
+  const pnpmWorkspaces = await detectPnpmWorkspaces(repoRoot);
+  if (pnpmWorkspaces.length > 0) {
+    result.isMonorepo = true;
+    result.tool = "pnpm workspaces";
+    result.packages = pnpmWorkspaces;
+    info(`Monorepo detected: ${result.tool} with ${result.packages.length} packages`);
+    return result;
+  }
+
+  // 3. Check lerna.json
+  const lernaPackages = await detectLerna(repoRoot);
+  if (lernaPackages.length > 0) {
+    result.isMonorepo = true;
+    result.tool = "Lerna";
+    result.packages = lernaPackages;
+    info(`Monorepo detected: ${result.tool} with ${result.packages.length} packages`);
+    return result;
+  }
+
+  return result;
+}
+
+async function detectNpmWorkspaces(repoRoot) {
+  try {
+    const pkgPath = path.join(repoRoot, "package.json");
+    const raw = await fs.readFile(pkgPath, "utf8");
+    const pkg = JSON.parse(raw);
+
+    if (!pkg.workspaces) return [];
+
+    // workspaces can be an array or { packages: [...] }
+    const patterns = Array.isArray(pkg.workspaces)
+      ? pkg.workspaces
+      : pkg.workspaces.packages || [];
+
+    return await resolveWorkspacePatterns(repoRoot, patterns);
+  } catch {
+    return [];
+  }
+}
+
+async function detectPnpmWorkspaces(repoRoot) {
+  try {
+    const yamlPath = path.join(repoRoot, "pnpm-workspace.yaml");
+    const raw = await fs.readFile(yamlPath, "utf8");
+
+    // Simple YAML parsing for packages array (avoid adding js-yaml dependency for this)
+    const patterns = [];
+    let inPackages = false;
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed === "packages:") {
+        inPackages = true;
+        continue;
+      }
+      if (inPackages) {
+        if (trimmed.startsWith("- ")) {
+          patterns.push(trimmed.slice(2).replace(/['"]/g, "").trim());
+        } else if (trimmed && !trimmed.startsWith("#")) {
+          break; // End of packages list
+        }
+      }
+    }
+
+    return await resolveWorkspacePatterns(repoRoot, patterns);
+  } catch {
+    return [];
+  }
+}
+
+async function detectLerna(repoRoot) {
+  try {
+    const lernaPath = path.join(repoRoot, "lerna.json");
+    const raw = await fs.readFile(lernaPath, "utf8");
+    const lerna = JSON.parse(raw);
+
+    const patterns = lerna.packages || ["packages/*"];
+    return await resolveWorkspacePatterns(repoRoot, patterns);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Resolve workspace glob patterns to actual package directories.
+ */
+async function resolveWorkspacePatterns(repoRoot, patterns) {
+  const packages = [];
+  const seen = new Set();
+
+  for (const pattern of patterns) {
+    // Convert glob pattern to directory search
+    // e.g. "packages/*" → list dirs in packages/
+    const basePath = pattern.replace(/\/?\*.*$/, "");
+    const searchDir = path.join(repoRoot, basePath);
+
+    try {
+      const entries = await fs.readdir(searchDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+
+        const pkgDir = path.join(searchDir, entry.name);
+        const pkgJsonPath = path.join(pkgDir, "package.json");
+
+        try {
+          const raw = await fs.readFile(pkgJsonPath, "utf8");
+          const pkg = JSON.parse(raw);
+          const relativePath = path.relative(repoRoot, pkgDir).replace(/\\/g, "/");
+
+          if (!seen.has(relativePath)) {
+            seen.add(relativePath);
+            packages.push({
+              name: pkg.name || entry.name,
+              path: relativePath,
+              version: pkg.version,
+              dependencies: Object.keys(pkg.dependencies || {}),
+              devDependencies: Object.keys(pkg.devDependencies || {}),
+            });
+          }
+        } catch {
+          // No package.json in this directory, skip
+        }
+      }
+    } catch {
+      // Directory doesn't exist, skip
+    }
+  }
+
+  return packages;
+}

package/src/core/scan.js

@@ -3,6 +3,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { info, warn } from "../utils/logger.js";
 import { trackScan } from "../utils/telemetry.js";
+import { detectMonorepo } from "../analyzers/monorepo-detector.js";
 
 const norm = (p) => p.replace(/\\/g, "/");
 
@@ -403,6 +404,9 @@ export async function scanRepo(cfg) {
   // Detect external API integrations
   const externalApis = await detectExternalApis(files, repoRoot);
 
+  // Detect monorepo workspaces
+  const monorepo = await detectMonorepo(repoRoot);
+
   const scanResult = {
     filesCount: files.length,
     modules,
@@ -410,6 +414,7 @@ export async function scanRepo(cfg) {
     pages,
     metadata,
     externalApis,
+    monorepo,
     _files: files
   };