@eduardbar/drift 1.3.0 → 1.5.0

package/dist/plugins.d.ts

@@ -1,4 +1,4 @@
-import type { PluginLoadError, PluginLoadWarning, LoadedPlugin } from './types.js';
+import type { LoadedPlugin, PluginLoadError, PluginLoadWarning } from './types.js';
 export declare function loadPlugins(projectRoot: string, pluginIds: string[] | undefined): {
     plugins: LoadedPlugin[];
     errors: PluginLoadError[];

package/dist/plugins.js

@@ -1,171 +1,72 @@
 import { existsSync } from 'node:fs';
 import { isAbsolute, resolve } from 'node:path';
 import { createRequire } from 'node:module';
+import { normalizeRules } from './plugins-rules.js';
+import { validateCapabilities } from './plugins-capabilities.js';
+import { pushError, pushWarning } from './plugins-messages.js';
 const require = createRequire(import.meta.url);
-const VALID_SEVERITIES = ['error', 'warning', 'info'];
 const SUPPORTED_PLUGIN_API_VERSION = 1;
-const RULE_ID_REQUIRED = /^[a-z][a-z0-9]*(?:[-_/][a-z0-9]+)*$/;
 function normalizePluginExport(mod) {
     if (mod && typeof mod === 'object' && 'default' in mod) {
         return mod.default ?? mod;
     }
     return mod;
 }
-function pushError(errors, pluginId, message, options) {
-    errors.push({
-        pluginId,
-        pluginName: options?.pluginName,
-        ruleId: options?.ruleId,
-        code: options?.code,
-        message,
-    });
-}
-function pushWarning(warnings, pluginId, message, options) {
-    warnings.push({
-        pluginId,
-        pluginName: options?.pluginName,
-        ruleId: options?.ruleId,
-        code: options?.code,
-        message,
-    });
-}
-function normalizeRule(pluginId, pluginName, rawRule, ruleIndex, options, errors, warnings) {
-    const rawRuleId = typeof rawRule.id === 'string'
-        ? rawRule.id.trim()
-        : typeof rawRule.name === 'string'
-            ? rawRule.name.trim()
-            : '';
-    const ruleLabel = rawRuleId || `rule#${ruleIndex + 1}`;
-    if (!rawRuleId) {
-        pushError(errors, pluginId, `Invalid rule at index ${ruleIndex}. Expected 'id' or 'name' as a non-empty string.`, { pluginName, code: 'plugin-rule-id-missing' });
-        return undefined;
-    }
-    if (typeof rawRule.detect !== 'function') {
-        pushError(errors, pluginId, `Rule '${rawRuleId}' is invalid. Expected 'detect(file, context)' function.`, { pluginName, ruleId: rawRuleId, code: 'plugin-rule-detect-invalid' });
-        return undefined;
-    }
-    if (rawRule.detect.length > 2) {
-        pushWarning(warnings, pluginId, `Rule '${rawRuleId}' detect() declares ${rawRule.detect.length} parameters. Expected 1-2 parameters (file, context).`, { pluginName, ruleId: rawRuleId, code: 'plugin-rule-detect-arity' });
-    }
-    if (!RULE_ID_REQUIRED.test(rawRuleId)) {
-        if (options.strictRuleId) {
-            pushError(errors, pluginId, `Rule id '${ruleLabel}' is invalid. Use lowercase letters, numbers, and separators (-, _, /), starting with a letter.`, { pluginName, ruleId: rawRuleId, code: 'plugin-rule-id-invalid' });
-            return undefined;
-        }
-        pushWarning(warnings, pluginId, `Rule id '${ruleLabel}' uses a legacy format. For forward compatibility, migrate to lowercase kebab-case and set apiVersion: ${SUPPORTED_PLUGIN_API_VERSION}.`, { pluginName, ruleId: rawRuleId, code: 'plugin-rule-id-format-legacy' });
-    }
-    let severity;
-    if (rawRule.severity !== undefined) {
-        if (typeof rawRule.severity === 'string' && VALID_SEVERITIES.includes(rawRule.severity)) {
-            severity = rawRule.severity;
-        }
-        else {
-            pushError(errors, pluginId, `Rule '${rawRuleId}' has invalid severity '${String(rawRule.severity)}'. Allowed: error, warning, info.`, { pluginName, ruleId: rawRuleId, code: 'plugin-rule-severity-invalid' });
-        }
-    }
-    let weight;
-    if (rawRule.weight !== undefined) {
-        if (typeof rawRule.weight === 'number' && Number.isFinite(rawRule.weight) && rawRule.weight >= 0 && rawRule.weight <= 100) {
-            weight = rawRule.weight;
-        }
-        else {
-            pushError(errors, pluginId, `Rule '${rawRuleId}' has invalid weight '${String(rawRule.weight)}'. Expected a finite number between 0 and 100.`, { pluginName, ruleId: rawRuleId, code: 'plugin-rule-weight-invalid' });
-        }
+function ensureObjectCandidate(pluginId, candidate, errors) {
+    if (candidate && typeof candidate === 'object') {
+        return candidate;
     }
-    let fix;
-    if (rawRule.fix !== undefined) {
-        if (typeof rawRule.fix === 'function') {
-            fix = rawRule.fix;
-            if (rawRule.fix.length > 3) {
-                pushWarning(warnings, pluginId, `Rule '${rawRuleId}' fix() declares ${rawRule.fix.length} parameters. Expected up to 3 (issue, file, context).`, { pluginName, ruleId: rawRuleId, code: 'plugin-rule-fix-arity' });
-            }
-        }
-        else {
-            pushError(errors, pluginId, `Rule '${rawRuleId}' has invalid fix. Expected a function when provided.`, { pluginName, ruleId: rawRuleId, code: 'plugin-rule-fix-invalid' });
-        }
-    }
-    return {
-        id: rawRuleId,
-        name: rawRuleId,
-        detect: rawRule.detect,
-        severity,
-        weight,
-        fix,
-    };
+    pushError(errors, pluginId, `Invalid plugin contract in '${pluginId}'. Expected an object export with shape { name, rules[] }`, { code: 'plugin-shape-invalid' });
+    return undefined;
 }
-function validatePluginContract(pluginId, candidate) {
-    const errors = [];
-    const warnings = [];
-    if (!candidate || typeof candidate !== 'object') {
-        pushError(errors, pluginId, `Invalid plugin contract in '${pluginId}'. Expected an object export with shape { name, rules[] }`, { code: 'plugin-shape-invalid' });
-        return { errors, warnings };
-    }
-    const plugin = candidate;
+function ensurePluginName(pluginId, plugin, errors) {
     const pluginName = typeof plugin.name === 'string' ? plugin.name.trim() : '';
-    if (!pluginName) {
-        pushError(errors, pluginId, `Invalid plugin contract in '${pluginId}'. Expected 'name' as a non-empty string.`, { code: 'plugin-name-missing' });
-        return { errors, warnings };
-    }
+    if (pluginName)
+        return pluginName;
+    pushError(errors, pluginId, `Invalid plugin contract in '${pluginId}'. Expected 'name' as a non-empty string.`, { code: 'plugin-name-missing' });
+    return undefined;
+}
+function validateApiVersion(plugin, context) {
+    const { pluginId, pluginName, errors, warnings } = context;
     const hasExplicitApiVersion = plugin.apiVersion !== undefined;
     const isLegacyPlugin = !hasExplicitApiVersion;
     if (isLegacyPlugin) {
         pushWarning(warnings, pluginId, `Plugin '${pluginName}' does not declare 'apiVersion'. Assuming ${SUPPORTED_PLUGIN_API_VERSION} for backward compatibility; please add apiVersion: ${SUPPORTED_PLUGIN_API_VERSION}.`, { pluginName, code: 'plugin-api-version-implicit' });
+        return { hasExplicitApiVersion, isLegacyPlugin, isSupported: true };
     }
-    else if (typeof plugin.apiVersion !== 'number' || !Number.isInteger(plugin.apiVersion) || plugin.apiVersion <= 0) {
+    if (typeof plugin.apiVersion !== 'number' || !Number.isInteger(plugin.apiVersion) || plugin.apiVersion <= 0) {
         pushError(errors, pluginId, `Plugin '${pluginName}' has invalid apiVersion '${String(plugin.apiVersion)}'. Expected a positive integer (for example: ${SUPPORTED_PLUGIN_API_VERSION}).`, { pluginName, code: 'plugin-api-version-invalid' });
-        return { errors, warnings };
+        return { hasExplicitApiVersion, isLegacyPlugin, isSupported: false };
     }
-    else if (plugin.apiVersion !== SUPPORTED_PLUGIN_API_VERSION) {
+    if (plugin.apiVersion !== SUPPORTED_PLUGIN_API_VERSION) {
         pushError(errors, pluginId, `Plugin '${pluginName}' targets apiVersion ${plugin.apiVersion}, but this drift build supports apiVersion ${SUPPORTED_PLUGIN_API_VERSION}.`, { pluginName, code: 'plugin-api-version-unsupported' });
-        return { errors, warnings };
+        return { hasExplicitApiVersion, isLegacyPlugin, isSupported: false };
     }
-    let capabilities;
-    if (plugin.capabilities !== undefined) {
-        if (!plugin.capabilities || typeof plugin.capabilities !== 'object' || Array.isArray(plugin.capabilities)) {
-            pushError(errors, pluginId, `Plugin '${pluginName}' has invalid capabilities metadata. Expected an object map like { "fixes": true } when provided.`, { pluginName, code: 'plugin-capabilities-invalid' });
-            return { errors, warnings };
-        }
-        const entries = Object.entries(plugin.capabilities);
-        for (const [capabilityKey, capabilityValue] of entries) {
-            const capabilityType = typeof capabilityValue;
-            if (capabilityType !== 'string' && capabilityType !== 'number' && capabilityType !== 'boolean') {
-                pushError(errors, pluginId, `Plugin '${pluginName}' capability '${capabilityKey}' has invalid value type '${capabilityType}'. Allowed: string | number | boolean.`, { pluginName, code: 'plugin-capabilities-value-invalid' });
-            }
-        }
-        if (errors.length > 0) {
-            return { errors, warnings };
-        }
-        capabilities = plugin.capabilities;
-    }
-    if (!Array.isArray(plugin.rules)) {
-        pushError(errors, pluginId, `Invalid plugin '${pluginName}'. Expected 'rules' to be an array.`, { pluginName, code: 'plugin-rules-not-array' });
+    return { hasExplicitApiVersion, isLegacyPlugin, isSupported: true };
+}
+function validatePluginContractData(pluginId, candidate) {
+    const errors = [];
+    const warnings = [];
+    const plugin = ensureObjectCandidate(pluginId, candidate, errors);
+    if (!plugin)
         return { errors, warnings };
-    }
-    const normalizedRules = [];
-    const seenRuleIds = new Set();
-    for (const [ruleIndex, rawRule] of plugin.rules.entries()) {
-        if (!rawRule || typeof rawRule !== 'object') {
-            pushError(errors, pluginId, `Invalid rule at index ${ruleIndex} in plugin '${pluginName}'. Expected an object.`, { pluginName, code: 'plugin-rule-shape-invalid' });
-            continue;
-        }
-        const normalized = normalizeRule(pluginId, pluginName, rawRule, ruleIndex, { strictRuleId: !isLegacyPlugin }, errors, warnings);
-        if (normalized) {
-            if (seenRuleIds.has(normalized.id ?? normalized.name)) {
-                pushError(errors, pluginId, `Plugin '${pluginName}' defines duplicate rule id '${normalized.id ?? normalized.name}'. Rule ids must be unique within a plugin.`, { pluginName, ruleId: normalized.id ?? normalized.name, code: 'plugin-rule-id-duplicate' });
-                continue;
-            }
-            seenRuleIds.add(normalized.id ?? normalized.name);
-            normalizedRules.push(normalized);
-        }
-    }
-    if (normalizedRules.length === 0) {
-        pushError(errors, pluginId, `Plugin '${pluginName}' has no valid rules after validation.`, { pluginName, code: 'plugin-rules-empty' });
+    const pluginName = ensurePluginName(pluginId, plugin, errors);
+    if (!pluginName)
+        return { errors, warnings };
+    const context = { pluginId, pluginName, errors, warnings };
+    const apiVersion = validateApiVersion(plugin, context);
+    if (!apiVersion.isSupported)
+        return { errors, warnings };
+    const capabilities = validateCapabilities(plugin.capabilities, context);
+    if (errors.length > 0)
+        return { errors, warnings };
+    const normalizedRules = normalizeRules(plugin.rules, apiVersion.isLegacyPlugin, context);
+    if (!normalizedRules)
         return { errors, warnings };
-    }
     return {
         plugin: {
             name: pluginName,
-            apiVersion: hasExplicitApiVersion ? plugin.apiVersion : SUPPORTED_PLUGIN_API_VERSION,
+            apiVersion: apiVersion.hasExplicitApiVersion ? plugin.apiVersion : SUPPORTED_PLUGIN_API_VERSION,
             capabilities,
             rules: normalizedRules,
         },
@@ -173,6 +74,9 @@ function validatePluginContract(pluginId, candidate) {
         warnings,
     };
 }
+function validatePluginContract(pluginId, candidate) {
+    return validatePluginContractData(pluginId, candidate);
+}
 function resolvePluginSpecifier(projectRoot, pluginId) {
     if (pluginId.startsWith('.') || pluginId.startsWith('/')) {
         const abs = isAbsolute(pluginId) ? pluginId : resolve(projectRoot, pluginId);
@@ -205,9 +109,8 @@ export function loadPlugins(projectRoot, pluginIds) {
             const validation = validatePluginContract(pluginId, normalized);
             errors.push(...validation.errors);
             warnings.push(...validation.warnings);
-            if (!validation.plugin) {
+            if (!validation.plugin)
                 continue;
-            }
             loaded.push({ id: pluginId, plugin: validation.plugin });
         }
         catch (error) {

package/dist/reporter-constants.d.ts

@@ -0,0 +1,16 @@
+import type { DriftIssue } from './types.js';
+export declare const FIX_SUGGESTIONS: Record<string, string>;
+export declare const RULE_EFFORT: Record<string, 'low' | 'medium' | 'high'>;
+export declare const SEVERITY_ORDER: Record<string, number>;
+export declare const EFFORT_ORDER: Record<string, number>;
+export declare const AI_SIGNAL_RULES: Set<string>;
+export declare const AI_CODE_SMELL_BOOST = 20;
+export declare const AI_TRIGGER_LIMIT = 4;
+export declare const AI_LIKELIHOOD_THRESHOLD = 35;
+export declare const AI_SMELL_SCORE_MULTIPLIER = 15;
+export declare const AI_SUSPECTED_LIMIT = 10;
+export type DriftIssueWithFile = {
+    file: string;
+    issue: DriftIssue;
+};
+//# sourceMappingURL=reporter-constants.d.ts.map

package/dist/reporter-constants.js

@@ -0,0 +1,39 @@
+export const FIX_SUGGESTIONS = {
+    'large-file': 'Consider splitting this file into smaller modules with single responsibility',
+    'large-function': 'Extract logic into smaller functions with descriptive names',
+    'debug-leftover': 'Remove this console.log or replace with proper logging library',
+    'dead-code': 'Remove unused import to keep code clean',
+    'duplicate-function-name': 'Consolidate with existing function or rename to clarify different behavior',
+    'any-abuse': "Replace 'any' with proper type definition",
+    'catch-swallow': 'Add error handling or logging in catch block',
+    'no-return-type': 'Add explicit return type for better type safety',
+};
+export const RULE_EFFORT = {
+    'debug-leftover': 'low',
+    'dead-code': 'low',
+    'no-return-type': 'low',
+    'any-abuse': 'medium',
+    'catch-swallow': 'medium',
+    'large-file': 'high',
+    'large-function': 'high',
+    'duplicate-function-name': 'high',
+};
+export const SEVERITY_ORDER = { error: 0, warning: 1, info: 2 };
+export const EFFORT_ORDER = { low: 0, medium: 1, high: 2 };
+export const AI_SIGNAL_RULES = new Set([
+    'over-commented',
+    'hardcoded-config',
+    'inconsistent-error-handling',
+    'unnecessary-abstraction',
+    'naming-inconsistency',
+    'comment-contradiction',
+    'promise-style-mix',
+    'any-abuse',
+    'ai-code-smell',
+]);
+export const AI_CODE_SMELL_BOOST = 20;
+export const AI_TRIGGER_LIMIT = 4;
+export const AI_LIKELIHOOD_THRESHOLD = 35;
+export const AI_SMELL_SCORE_MULTIPLIER = 15;
+export const AI_SUSPECTED_LIMIT = 10;
+//# sourceMappingURL=reporter-constants.js.map

package/dist/reporter.d.ts

@@ -1,5 +1,5 @@
-import type { FileReport, DriftReport, AIOutput } from './types.js';
-export declare function buildReport(targetPath: string, files: FileReport[]): DriftReport;
+import type { FileReport, DriftReport, AIOutputJson, DriftReportJson } from './types.js';
+export declare function buildReport(targetPath: string, files: FileReport[]): DriftReportJson;
 export declare function formatMarkdown(report: DriftReport): string;
-export declare function formatAIOutput(report: DriftReport): AIOutput;
+export declare function formatAIOutput(report: DriftReport): AIOutputJson;
 //# sourceMappingURL=reporter.d.ts.map

package/dist/reporter.js

@@ -1,61 +1,34 @@
 import { scoreToGradeText, severityIcon } from './utils.js';
 import { computeRepoQuality, computeMaintenanceRisk } from './metrics.js';
-const FIX_SUGGESTIONS = {
-    'large-file': 'Consider splitting this file into smaller modules with single responsibility',
-    'large-function': 'Extract logic into smaller functions with descriptive names',
-    'debug-leftover': 'Remove this console.log or replace with proper logging library',
-    'dead-code': 'Remove unused import to keep code clean',
-    'duplicate-function-name': 'Consolidate with existing function or rename to clarify different behavior',
-    'any-abuse': "Replace 'any' with proper type definition",
-    'catch-swallow': 'Add error handling or logging in catch block',
-    'no-return-type': 'Add explicit return type for better type safety',
-};
-const RULE_EFFORT = {
-    'debug-leftover': 'low',
-    'dead-code': 'low',
-    'no-return-type': 'low',
-    'any-abuse': 'medium',
-    'catch-swallow': 'medium',
-    'large-file': 'high',
-    'large-function': 'high',
-    'duplicate-function-name': 'high',
-};
-const SEVERITY_ORDER = { error: 0, warning: 1, info: 2 };
-const EFFORT_ORDER = { low: 0, medium: 1, high: 2 };
-const AI_SIGNAL_RULES = new Set([
-    'over-commented',
-    'hardcoded-config',
-    'inconsistent-error-handling',
-    'unnecessary-abstraction',
-    'naming-inconsistency',
-    'comment-contradiction',
-    'promise-style-mix',
-    'any-abuse',
-    'ai-code-smell',
-]);
-export function buildReport(targetPath, files) {
-    const allIssues = files.flatMap((f) => f.issues);
+import { OUTPUT_SCHEMA, withOutputMetadata } from './output-metadata.js';
+import { AI_CODE_SMELL_BOOST, AI_LIKELIHOOD_THRESHOLD, AI_SIGNAL_RULES, AI_SMELL_SCORE_MULTIPLIER, AI_SUSPECTED_LIMIT, AI_TRIGGER_LIMIT, EFFORT_ORDER, FIX_SUGGESTIONS, RULE_EFFORT, SEVERITY_ORDER, } from './reporter-constants.js';
+function summarizeIssues(allIssues) {
     const byRule = {};
     for (const issue of allIssues) {
         byRule[issue.rule] = (byRule[issue.rule] ?? 0) + 1;
     }
-    const totalScore = files.length > 0
-        ? Math.round(files.reduce((sum, f) => sum + f.score, 0) / files.length)
-        : 0;
-    const sortedFiles = files.filter((f) => f.issues.length > 0).sort((a, b) => b.score - a.score);
-    const baseReport = {
+    return {
+        errors: allIssues.filter((issue) => issue.severity === 'error').length,
+        warnings: allIssues.filter((issue) => issue.severity === 'warning').length,
+        infos: allIssues.filter((issue) => issue.severity === 'info').length,
+        byRule,
+    };
+}
+function calculateTotalScore(files) {
+    if (files.length === 0)
+        return 0;
+    return Math.round(files.reduce((sum, file) => sum + file.score, 0) / files.length);
+}
+function baseReportDefaults(summary, targetPath, files) {
+    const filesWithIssues = files.filter((file) => file.issues.length > 0).sort((a, b) => b.score - a.score);
+    const report = {
         scannedAt: new Date().toISOString(),
         targetPath,
-        files: sortedFiles,
-        totalIssues: allIssues.length,
-        totalScore,
+        files: filesWithIssues,
+        totalIssues: files.flatMap((file) => file.issues).length,
+        totalScore: calculateTotalScore(files),
         totalFiles: files.length,
-        summary: {
-            errors: allIssues.filter((i) => i.severity === 'error').length,
-            warnings: allIssues.filter((i) => i.severity === 'warning').length,
-            infos: allIssues.filter((i) => i.severity === 'info').length,
-            byRule,
-        },
+        summary,
         quality: {
             overall: 100,
             dimensions: {
@@ -76,6 +49,12 @@ export function buildReport(targetPath, files) {
             },
         },
     };
+    return withOutputMetadata(report, OUTPUT_SCHEMA.report);
+}
+export function buildReport(targetPath, files) {
+    const allIssues = files.flatMap((f) => f.issues);
+    const summary = summarizeIssues(allIssues);
+    const baseReport = baseReportDefaults(summary, targetPath, files);
     baseReport.quality = computeRepoQuality(targetPath, files);
     baseReport.maintenanceRisk = computeMaintenanceRisk(baseReport);
     return baseReport;
@@ -191,12 +170,12 @@ function fileAILikelihood(fileIssues) {
         triggerCounts.set(issue.rule, (triggerCounts.get(issue.rule) ?? 0) + 1);
     }
     const triggerTotal = [...triggerCounts.values()].reduce((sum, count) => sum + count, 0);
-    const smellBoost = fileIssues.some((issue) => issue.rule === 'ai-code-smell') ? 20 : 0;
+    const smellBoost = fileIssues.some((issue) => issue.rule === 'ai-code-smell') ? AI_CODE_SMELL_BOOST : 0;
     const ratioScore = Math.round((triggerTotal / Math.max(fileIssues.length, 1)) * 100);
     const score = Math.max(0, Math.min(100, ratioScore + smellBoost));
     const triggers = [...triggerCounts.entries()]
         .sort((a, b) => b[1] - a[1])
-        .slice(0, 4)
+        .slice(0, AI_TRIGGER_LIMIT)
         .map(([rule]) => rule);
     return { score, triggers };
 }
@@ -210,16 +189,16 @@ function computeAILikelihood(report) {
             triggers: likelihood.triggers,
         };
     })
-        .filter((entry) => entry.ai_likelihood >= 35)
+        .filter((entry) => entry.ai_likelihood >= AI_LIKELIHOOD_THRESHOLD)
         .sort((a, b) => b.ai_likelihood - a.ai_likelihood);
     const overall = suspected.length === 0
         ? 0
         : Math.round(suspected.reduce((sum, entry) => sum + entry.ai_likelihood, 0) / suspected.length);
     const smellCount = report.files.flatMap((file) => file.issues).filter((issue) => issue.rule === 'ai-code-smell').length;
-    const smellScore = Math.min(100, smellCount * 15);
+    const smellScore = Math.min(100, smellCount * AI_SMELL_SCORE_MULTIPLIER);
     return {
         overall,
-        files: suspected.slice(0, 10),
+        files: suspected.slice(0, AI_SUSPECTED_LIMIT),
         smellScore,
     };
 }
@@ -230,7 +209,7 @@ export function formatAIOutput(report) {
     const rulesDetected = [...new Set(allIssues.map((i) => i.issue.rule))];
     const grade = scoreToGradeText(report.totalScore);
     const aiLikelihood = computeAILikelihood(report);
-    return {
+    const output = {
         summary: {
             score: report.totalScore,
             grade: grade.label.toUpperCase(),
@@ -251,5 +230,6 @@ export function formatAIOutput(report) {
             recommended_action: buildRecommendedAction(priorityOrder),
         },
     };
+    return withOutputMetadata(output, OUTPUT_SCHEMA.ai);
 }
 //# sourceMappingURL=reporter.js.map

package/dist/review.d.ts

@@ -1,5 +1,5 @@
 import type { DriftDiff } from './types.js';
-export interface DriftReview {
+interface DriftReview {
     baseRef: string;
     scannedAt: string;
     totalDelta: number;
@@ -12,4 +12,5 @@ export interface DriftReview {
 }
 export declare function formatReviewMarkdown(review: DriftReview): string;
 export declare function generateReview(projectPath: string, baseRef: string): Promise<DriftReview>;
+export {};
 //# sourceMappingURL=review.d.ts.map

package/dist/review.js

@@ -4,10 +4,11 @@ import { loadConfig } from './config.js';
 import { buildReport } from './reporter.js';
 import { cleanupTempDir, extractFilesAtRef } from './git.js';
 import { computeDiff } from './diff.js';
+const REVIEW_TOP_FILES_LIMIT = 8;
 export function formatReviewMarkdown(review) {
     const trendIcon = review.status === 'regressed' ? '⚠️' : review.status === 'improved' ? '✅' : 'ℹ️';
     const topFiles = review.diff.files
-        .slice(0, 8)
+        .slice(0, REVIEW_TOP_FILES_LIMIT)
         .map((file) => {
         const sign = file.scoreDelta > 0 ? '+' : '';
         return `- \`${file.path}\`: ${file.scoreBefore} -> ${file.scoreAfter} (${sign}${file.scoreDelta}), +${file.newIssues.length} new / -${file.resolvedIssues.length} resolved`;

package/dist/rules/phase3-configurable.js

@@ -19,11 +19,13 @@ const HTTP_IMPORT_PATTERNS = [
 ];
 function isControllerFile(filePath) {
     const normalized = filePath.replace(/\\/g, '/').toLowerCase();
-    return normalized.includes('/controller/') || normalized.includes('/controllers/') || normalized.endsWith('controller.ts') || normalized.endsWith('controller.js');
+    const segments = normalized.split('/');
+    return segments.includes('controller') || segments.includes('controllers') || normalized.endsWith('controller.ts') || normalized.endsWith('controller.js');
 }
 function isServiceFile(filePath) {
     const normalized = filePath.replace(/\\/g, '/').toLowerCase();
-    return normalized.includes('/service/') || normalized.includes('/services/') || normalized.endsWith('service.ts') || normalized.endsWith('service.js');
+    const segments = normalized.split('/');
+    return segments.includes('service') || segments.includes('services') || normalized.endsWith('service.ts') || normalized.endsWith('service.js');
 }
 function createIssue(rule, message, line, snippet) {
     return {
@@ -74,24 +76,30 @@ export function detectMaxFunctionLines(file, config) {
     if (!maxLines || maxLines <= 0)
         return [];
     const issues = [];
+    collectFunctionLineIssues(file, maxLines, issues);
+    collectMethodLineIssues(file, maxLines, issues);
+    return issues;
+}
+function countBodyLines(body) {
+    if (!body)
+        return 0;
+    return body.getEndLineNumber() - body.getStartLineNumber() - 1;
+}
+function collectFunctionLineIssues(file, maxLines, issues) {
     for (const fn of file.getFunctions()) {
-        const body = fn.getBody();
-        if (!body)
+        const lines = countBodyLines(fn.getBody());
+        if (lines <= maxLines)
             continue;
-        const lines = body.getEndLineNumber() - body.getStartLineNumber() - 1;
-        if (lines > maxLines) {
-            issues.push(createIssue('max-function-lines', `Function '${fn.getName() ?? '(anonymous)'}' has ${lines} lines (max: ${maxLines}).`, fn.getStartLineNumber(), fn.getName() ?? '(anonymous)'));
-        }
+        const functionName = fn.getName() ?? '(anonymous)';
+        issues.push(createIssue('max-function-lines', `Function '${functionName}' has ${lines} lines (max: ${maxLines}).`, fn.getStartLineNumber(), functionName));
     }
+}
+function collectMethodLineIssues(file, maxLines, issues) {
     for (const method of file.getDescendantsOfKind(SyntaxKind.MethodDeclaration)) {
-        const body = method.getBody();
-        if (!body)
+        const lines = countBodyLines(method.getBody());
+        if (lines <= maxLines)
             continue;
-        const lines = body.getEndLineNumber() - body.getStartLineNumber() - 1;
-        if (lines > maxLines) {
-            issues.push(createIssue('max-function-lines', `Method '${method.getName()}' has ${lines} lines (max: ${maxLines}).`, method.getStartLineNumber(), method.getName()));
-        }
+        issues.push(createIssue('max-function-lines', `Method '${method.getName()}' has ${lines} lines (max: ${maxLines}).`, method.getStartLineNumber(), method.getName()));
     }
-    return issues;
 }
 //# sourceMappingURL=phase3-configurable.js.map

package/dist/saas/constants.d.ts

@@ -0,0 +1,15 @@
+import type { SaasOperation, SaasPlan, SaasPolicy, SaasRole } from './types.js';
+export declare const STORE_VERSION = 3;
+export declare const ACTIVE_WINDOW_DAYS = 30;
+export declare const DEFAULT_ORGANIZATION_ID = "default-org";
+export declare const DASHBOARD_REPO_LIMIT = 15;
+export declare const DASHBOARD_BAR_UNIT = 8;
+export declare const DASHBOARD_BAR_MIN_WIDTH = 8;
+export declare const VALID_ROLES: SaasRole[];
+export declare const VALID_PLANS: SaasPlan[];
+export declare const ROLE_PRIORITY: Record<SaasRole, number>;
+export declare const REQUIRED_ROLE_BY_OPERATION: Record<SaasOperation, SaasRole>;
+export declare const DEFAULT_SAAS_POLICY: SaasPolicy;
+export declare function daysAgo(days: number): number;
+export declare function createRandomId(prefix: string): string;
+//# sourceMappingURL=constants.d.ts.map

package/dist/saas/constants.js

@@ -0,0 +1,48 @@
+export const STORE_VERSION = 3;
+export const ACTIVE_WINDOW_DAYS = 30;
+export const DEFAULT_ORGANIZATION_ID = 'default-org';
+const HOURS_PER_DAY = 24;
+const MINUTES_PER_HOUR = 60;
+const SECONDS_PER_MINUTE = 60;
+const MILLISECONDS_PER_SECOND = 1000;
+const RANDOM_ID_RADIX = 16;
+const RANDOM_ID_START = 2;
+const RANDOM_ID_END = 10;
+export const DASHBOARD_REPO_LIMIT = 15;
+export const DASHBOARD_BAR_UNIT = 8;
+export const DASHBOARD_BAR_MIN_WIDTH = 8;
+export const VALID_ROLES = ['owner', 'member', 'viewer'];
+export const VALID_PLANS = ['free', 'sponsor', 'team', 'business'];
+export const ROLE_PRIORITY = {
+    viewer: 1,
+    member: 2,
+    owner: 3,
+};
+export const REQUIRED_ROLE_BY_OPERATION = {
+    'snapshot:write': 'member',
+    'snapshot:read': 'viewer',
+    'summary:read': 'viewer',
+    'billing:write': 'owner',
+    'billing:read': 'viewer',
+};
+export const DEFAULT_SAAS_POLICY = {
+    freeUserThreshold: 7500,
+    maxRunsPerWorkspacePerMonth: 500,
+    maxReposPerWorkspace: 20,
+    retentionDays: 90,
+    strictActorEnforcement: false,
+    maxWorkspacesPerOrganizationByPlan: {
+        free: 20,
+        sponsor: 50,
+        team: 200,
+        business: 1000,
+    },
+};
+export function daysAgo(days) {
+    const now = Date.now();
+    return now - days * HOURS_PER_DAY * MINUTES_PER_HOUR * SECONDS_PER_MINUTE * MILLISECONDS_PER_SECOND;
+}
+export function createRandomId(prefix) {
+    return `${prefix}-${Math.random().toString(RANDOM_ID_RADIX).slice(RANDOM_ID_START, RANDOM_ID_END)}`;
+}
+//# sourceMappingURL=constants.js.map

package/dist/saas/dashboard.d.ts

@@ -0,0 +1,8 @@
+import type { SaasPolicyOverrides, SaasQueryOptions, SaasSnapshot, SaasSummary } from './types.js';
+export declare function listSaasSnapshots(options?: SaasQueryOptions): SaasSnapshot[];
+export declare function getSaasSummary(options?: SaasQueryOptions): SaasSummary;
+export declare function generateSaasDashboardHtml(options?: {
+    storeFile?: string;
+    policy?: SaasPolicyOverrides;
+}): string;
+//# sourceMappingURL=dashboard.d.ts.map