@chappibunny/repolens 0.9.0 → 1.1.0

package/src/utils/branch.js

@@ -112,6 +112,33 @@ export function shouldPublishToConfluence(config, currentBranch = getCurrentBran
   });
 }
 
+/**
+ * Check if current branch should publish to GitHub Wiki
+ * Based on config.github_wiki.branches setting
+ */
+export function shouldPublishToGitHubWiki(config, currentBranch = getCurrentBranch()) {
+  if (!config.github_wiki) {
+    return true;
+  }
+
+  if (!config.github_wiki.branches || config.github_wiki.branches.length === 0) {
+    return true;
+  }
+
+  return config.github_wiki.branches.some(pattern => {
+    if (pattern === currentBranch) {
+      return true;
+    }
+
+    if (pattern.includes("*")) {
+      const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+      return regex.test(currentBranch);
+    }
+
+    return false;
+  });
+}
+
 /**
  * Get branch-qualified page title
  */

package/src/utils/rate-limit.js

@@ -5,6 +5,8 @@
  * to prevent abuse and respect API limits.
  */
 
+import { warn } from "./logger.js";
+
 /**
  * Rate limiter class using token bucket algorithm
  */
@@ -193,7 +195,7 @@ export async function executeNotionRequest(fn, options = {}) {
         if (options.onRetry) {
           options.onRetry(attempt, maxRetries, delay, error);
         } else {
-          console.warn(
+          warn(
             `Notion API retry ${attempt}/${maxRetries} after ${Math.round(delay)}ms (${error.message})`
           );
         }
@@ -221,7 +223,7 @@ export async function executeAIRequest(fn, options = {}) {
         if (options.onRetry) {
           options.onRetry(attempt, maxRetries, delay, error);
         } else {
-          console.warn(
+          warn(
             `AI API retry ${attempt}/${maxRetries} after ${Math.round(delay)}ms (${error.message})`
           );
         }

package/src/utils/telemetry.js

@@ -33,8 +33,10 @@ export function initTelemetry() {
     const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
     const version = packageJson.version || "unknown";
 
+    const dsn = process.env.REPOLENS_SENTRY_DSN || "https://082083dbf5899ed7e65dfd9b8dc72f90@o4511014913703936.ingest.de.sentry.io/4511014919209040";
+
     Sentry.init({
-      dsn: "https://082083dbf5899ed7e65dfd9b8dc72f90@o4511014913703936.ingest.de.sentry.io/4511014919209040", // TODO: Replace with actual DSN
+      dsn,
       
       // Release tracking
       release: `repolens@${version}`,
@@ -412,8 +414,10 @@ function ensureSentryForFeedback() {
     const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
     const version = packageJson.version || "unknown";
 
+    const dsn = process.env.REPOLENS_SENTRY_DSN || "https://082083dbf5899ed7e65dfd9b8dc72f90@o4511014913703936.ingest.de.sentry.io/4511014919209040";
+
     Sentry.init({
-      dsn: "https://082083dbf5899ed7e65dfd9b8dc72f90@o4511014913703936.ingest.de.sentry.io/4511014919209040",
+      dsn,
       release: `repolens@${version}`,
       environment: process.env.NODE_ENV || "production",
       sampleRate: 1.0, // Always send feedback

package/src/utils/update-check.js

@@ -104,7 +104,7 @@ export async function checkForUpdates() {
 }
 
 function showUpdateMessage(current, latest) {
-  console.log("");
+  info("");
   warn("┌────────────────────────────────────────────────────────────┐");
   warn("│                   📦 Update Available                      │");
   warn("├────────────────────────────────────────────────────────────┤");
@@ -118,7 +118,7 @@ function showUpdateMessage(current, latest) {
   warn("│                                                            │");
   warn("│  Release notes: https://github.com/CHAPIBUNNY/repolens    │");
   warn("└────────────────────────────────────────────────────────────┘");
-  console.log("");
+  info("");
 }
 
 export async function forceCheckForUpdates() {

package/src/utils/validate.js

@@ -103,13 +103,13 @@ function validateScanConfig(scan) {
     }
   }
   
-  if (scan.exclude) {
-    if (!Array.isArray(scan.exclude)) {
-      errors.push("scan.exclude must be an array of glob patterns");
+  if (scan.ignore) {
+    if (!Array.isArray(scan.ignore)) {
+      errors.push("scan.ignore must be an array of glob patterns");
     } else {
-      for (const pattern of scan.exclude) {
+      for (const pattern of scan.ignore) {
         if (typeof pattern !== "string") {
-          errors.push(`Invalid pattern in scan.exclude: ${pattern} (must be string)`);
+          errors.push(`Invalid pattern in scan.ignore: ${pattern} (must be string)`);
           continue; // Skip further checks if not a string
         }
       }
@@ -135,7 +135,7 @@ function validatePublishers(publishers) {
     return errors;
   }
   
-  const validPublishers = ["notion", "markdown", "confluence"];
+  const validPublishers = ["notion", "markdown", "confluence", "github_wiki"];
   
   if (Array.isArray(publishers)) {
     for (const pub of publishers) {
@@ -207,33 +207,34 @@ function checkNotionWarnings(notion) {
 }
 
 /**
- * Validate domains configuration
+ * Validate domains configuration (object format: { key: { match: [], description? } })
  */
 function validateDomains(domains) {
   const errors = [];
   
-  if (!Array.isArray(domains)) {
-    errors.push("domains must be an array");
+  if (typeof domains !== "object" || Array.isArray(domains)) {
+    errors.push("domains must be an object");
     return errors;
   }
   
-  for (const domain of domains) {
-    if (!domain.name || typeof domain.name !== "string") {
-      errors.push("Each domain must have a 'name' field (string)");
+  for (const [key, domain] of Object.entries(domains)) {
+    if (typeof domain !== "object" || Array.isArray(domain)) {
+      errors.push(`domains.${key} must be an object`);
+      continue;
     }
     
-    if (!domain.patterns || !Array.isArray(domain.patterns)) {
-      errors.push(`Domain '${domain.name}' must have 'patterns' array`);
+    if (!domain.match || !Array.isArray(domain.match)) {
+      errors.push(`domains.${key} must have a 'match' array`);
     } else {
-      for (const pattern of domain.patterns) {
+      for (const pattern of domain.match) {
         if (typeof pattern !== "string") {
-          errors.push(`Invalid pattern in domain '${domain.name}': ${pattern}`);
+          errors.push(`Invalid pattern in domains.${key}.match: ${pattern}`);
         }
       }
     }
     
     if (domain.description && typeof domain.description !== "string") {
-      errors.push(`Domain '${domain.name}' description must be a string`);
+      errors.push(`domains.${key}.description must be a string`);
     }
   }
   
@@ -319,17 +320,25 @@ function checkForInjection(config) {
     });
   }
   
-  // Check domain patterns
-  if (config.domains && Array.isArray(config.domains)) {
-    config.domains.forEach((domain, i) => {
-      if (domain.patterns && Array.isArray(domain.patterns)) {
-        domain.patterns.forEach((pattern, j) => {
+  if (config.scan?.ignore && Array.isArray(config.scan.ignore)) {
+    config.scan.ignore.forEach((pattern, i) => {
+      if (typeof pattern === "string") {
+        checkString(pattern, `scan.ignore[${i}]`);
+      }
+    });
+  }
+  
+  // Check domain patterns (object format: { key: { match: [] } })
+  if (config.domains && typeof config.domains === "object" && !Array.isArray(config.domains)) {
+    for (const [domainKey, domain] of Object.entries(config.domains)) {
+      if (domain.match && Array.isArray(domain.match)) {
+        domain.match.forEach((pattern, j) => {
           if (typeof pattern === "string") {
-            checkString(pattern, `domains[${i}].patterns[${j}]`);
+            checkString(pattern, `domains.${domainKey}.match[${j}]`);
           }
         });
       }
-    });
+    }
   }
   
   return errors;