@eddacraft/anvil-core 0.1.0

package/dist/explain/boundary-explainer.js

@@ -0,0 +1,261 @@
+import { registerTemplate } from './template-loader.js';
+const ARCH_RULES = {
+    'ARCH-001': {
+        id: 'ARCH-001',
+        name: 'Circular dependency',
+        description: 'A circular dependency chain was detected in imports.',
+    },
+    'ARCH-002': {
+        id: 'ARCH-002',
+        name: 'Orphan module',
+        description: 'This module is not imported by any other module.',
+    },
+    'ARCH-003': {
+        id: 'ARCH-003',
+        name: 'Layer boundary violation',
+        description: 'An import crosses an architectural layer boundary.',
+    },
+    'ARCH-004': {
+        id: 'ARCH-004',
+        name: 'Architecture violation',
+        description: 'General architecture rule violation detected.',
+    },
+    'BOUND-001': {
+        id: 'BOUND-001',
+        name: 'Boundary violation',
+        description: 'A new cross-boundary dependency was detected.',
+    },
+};
+function createBoundaryExplanation(ruleId, context) {
+    const ruleInfo = ARCH_RULES[ruleId];
+    if (!ruleInfo) {
+        return createFallbackExplanation(ruleId, context);
+    }
+    const locationSummary = formatLocationSummary(ruleId, context);
+    return {
+        ruleId,
+        title: ruleInfo.name,
+        summary: locationSummary,
+        whyItMatters: {
+            title: 'WHY THIS WARNING EXISTS',
+            content: getWhyContent(ruleId, context),
+        },
+        howToAddress: {
+            title: 'HOW TO ADDRESS',
+            content: getHowContent(ruleId, context),
+        },
+        whenToSuppress: {
+            title: 'WHEN TO SUPPRESS',
+            content: getWhenToSuppressContent(ruleId),
+        },
+        related: {
+            ruleDefinition: `${ruleId} in architecture rules`,
+            similarWarnings: context.similarCount,
+        },
+    };
+}
+function formatLocationSummary(ruleId, context) {
+    if (context.fromFile && context.toFile) {
+        return `${context.fromFile} → ${context.toFile}`;
+    }
+    return `${ruleId} at ${context.file}:${context.line}`;
+}
+function getWhyContent(ruleId, context) {
+    const layerContext = context.fromLayer && context.toLayer
+        ? `\n\nIn this case, ${context.fromLayer} is importing from ${context.toLayer}.`
+        : '';
+    const whyContent = {
+        'ARCH-001': `
+Circular dependencies create tightly coupled code that is:
+
+- Difficult to test in isolation
+- Hard to understand (dependencies loop back)
+- Prone to initialisation order bugs
+- Resistant to refactoring
+
+The dependency chain forms a cycle, meaning module A depends on B,
+which depends on C, which depends back on A.${layerContext}`,
+        'ARCH-002': `
+Orphan modules are files that no other code imports. This may indicate:
+
+- Dead code that should be removed
+- Missing integration (forgot to wire it up)
+- Incorrect file organisation
+- A utility that lost its callers after refactoring
+
+While not always a problem, orphans often represent unused code
+that adds maintenance burden.`,
+        'ARCH-003': `
+This import violates defined layer boundaries. Layer violations:
+
+- Break architectural contracts
+- Create hidden dependencies
+- Make changes risky (unknown blast radius)
+- Complicate testing and deployment${layerContext}`,
+        'ARCH-004': `
+This code violates an architecture rule defined for your project.
+
+Architecture rules exist to:
+- Enforce separation of concerns
+- Prevent coupling between unrelated modules
+- Maintain clear dependency direction
+- Enable independent testing and deployment${layerContext}`,
+        'BOUND-001': `
+A NEW cross-boundary dependency was introduced. This means code
+that previously didn't exist is now crossing an architectural boundary.
+
+New boundary violations are significant because:
+- They indicate potential architecture drift
+- The change was made without considering boundaries
+- They may create precedent for further violations${layerContext}`,
+    };
+    return (whyContent[ruleId] ?? ARCH_RULES[ruleId]?.description ?? 'Architecture violation detected.');
+}
+function getHowContent(ruleId, context) {
+    const howContent = {
+        'ARCH-001': `
+1. Identify the cycle
+   Look at the import chain to understand how modules connect
+
+2. Break the cycle using one of these patterns:
+   - Extract shared code to a common module
+   - Use dependency injection
+   - Introduce an interface/abstraction layer
+   - Merge tightly coupled modules
+
+3. Consider if the modules should be combined
+   Sometimes circular deps indicate a single concept split artificially`,
+        'ARCH-002': `
+1. Verify the module is actually unused
+   Search for dynamic imports or test files that might use it
+
+2. If unused, consider removing it
+   Dead code adds maintenance burden
+
+3. If it should be used, add the missing integration
+   Wire it into the appropriate consumer
+
+4. If it's a utility, document its purpose
+   Make sure others know it exists and when to use it`,
+        'ARCH-003': `
+1. Understand the layer structure
+   Review which layer should depend on which
+
+2. Consider using an intermediary
+   If presentation needs data, go through application layer
+
+3. Move the code to the appropriate layer
+   Sometimes code is in the wrong place
+
+4. Use dependency inversion
+   Depend on abstractions, not concretions`,
+        'ARCH-004': `
+1. Review the architecture rule being violated
+   Understand why the rule exists
+
+2. Determine if the violation is intentional
+   Sometimes rules need exceptions
+
+3. Refactor to comply with the rule
+   Or propose a rule change if it's outdated`,
+        'BOUND-001': `
+1. Understand what boundary was crossed
+   ${context.fromLayer ? `From: ${context.fromLayer}` : ''}
+   ${context.toLayer ? `To: ${context.toLayer}` : ''}
+
+2. Consider the proper path
+   Is there an existing service or abstraction to use?
+
+3. If the boundary is wrong, update architecture
+   Boundaries should reflect actual needs
+
+4. If crossing is necessary, suppress with explanation
+   Document why this exception exists`,
+    };
+    return howContent[ruleId] ?? 'Review the architecture and consider refactoring.';
+}
+function getWhenToSuppressContent(ruleId) {
+    const suppressionContent = {
+        'ARCH-001': `
+Suppress only if:
+- The cycle is intentional and well-understood
+- Breaking it would require major refactoring with a planned ticket
+- The modules are conceptually a single unit
+
+Example:
+// @anvil-ignore ARCH-001: mutually recursive parsers, by design`,
+        'ARCH-002': `
+Suppress only if:
+- The module is a valid entry point (e.g., CLI, test setup)
+- It's dynamically imported in ways not detected
+- It's intentionally a standalone utility
+
+Example:
+// @anvil-ignore ARCH-002: CLI entry point, not imported`,
+        'ARCH-003': `
+Suppress only if:
+- The layer structure doesn't fit this use case
+- You're actively migrating and have a ticket
+- This is a pragmatic exception with clear reasoning
+
+Example:
+// @anvil-ignore ARCH-003: legacy code, migrating in JIRA-789`,
+        'ARCH-004': `
+Suppress only if:
+- The rule is overly strict for this case
+- A rule change is pending
+- This is a documented exception
+
+Example:
+// @anvil-ignore ARCH-004: approved exception per ADR-042`,
+        'BOUND-001': `
+Suppress only if:
+- The new dependency is intentional and reviewed
+- The architecture definition needs updating
+- This is a temporary bridge during migration
+
+Example:
+// @anvil-ignore BOUND-001: approved in PR review, updating baseline`,
+    };
+    return (suppressionContent[ruleId] ??
+        `
+Suppress only with clear justification.
+Use: // @anvil-ignore ${ruleId}: [your reason]`);
+}
+function createFallbackExplanation(ruleId, context) {
+    return {
+        ruleId,
+        title: `Architecture violation ${ruleId}`,
+        summary: `Violation at ${context.file}:${context.line}`,
+        whyItMatters: {
+            title: 'WHY THIS WARNING EXISTS',
+            content: 'This warning indicates an architecture boundary violation.',
+        },
+        howToAddress: {
+            title: 'HOW TO ADDRESS',
+            content: 'Review the architecture and consider refactoring.',
+        },
+        whenToSuppress: {
+            title: 'WHEN TO SUPPRESS',
+            content: `Use: // @anvil-ignore ${ruleId}: [reason]`,
+        },
+    };
+}
+export function registerBoundaryTemplates() {
+    for (const ruleId of Object.keys(ARCH_RULES)) {
+        const template = {
+            ruleId,
+            render: (context) => createBoundaryExplanation(ruleId, context),
+        };
+        registerTemplate(template);
+    }
+}
+export function getBoundaryExplanation(ruleId, context) {
+    if (!ARCH_RULES[ruleId]) {
+        return null;
+    }
+    return createBoundaryExplanation(ruleId, context);
+}
+export function isArchitectureRule(ruleId) {
+    return ruleId in ARCH_RULES;
+}

package/dist/explain/explain-service.d.ts

@@ -0,0 +1,19 @@
+import type { Warning } from '../antipattern/types.js';
+import type { ExplanationContext, WarningExplanation } from './types.js';
+export declare function resetExplainService(): void;
+export declare function initExplainService(): void;
+export declare function explainWarning(warning: Warning, allWarnings?: Warning[]): WarningExplanation;
+export declare function explainById(warningId: string, warnings: Warning[]): WarningExplanation | null;
+export declare function explainByRule(ruleId: string, context?: Partial<ExplanationContext>): WarningExplanation | null;
+export interface ListWarningsResult {
+    warningId: string;
+    ruleId: string;
+    file: string;
+    line: number;
+    title: string;
+    severity: string;
+}
+export declare function listWarnings(warnings: Warning[]): ListWarningsResult[];
+export declare function isExplainable(ruleId: string): boolean;
+export declare function getExplainableRules(): string[];
+//# sourceMappingURL=explain-service.d.ts.map

package/dist/explain/explain-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explain-service.d.ts","sourceRoot":"","sources":["../../src/explain/explain-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AA+BzE,wBAAgB,mBAAmB,IAAI,IAAI,CAG1C;AAED,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC;AAoBD,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,OAAO,EAAE,GAAG,kBAAkB,CAkB5F;AAED,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,kBAAkB,GAAG,IAAI,CAgB7F;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,GACpC,kBAAkB,GAAG,IAAI,CAuB3B;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,kBAAkB,EAAE,CAWtE;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAGrD;AAED,wBAAgB,mBAAmB,IAAI,MAAM,EAAE,CAK9C"}

package/dist/explain/explain-service.js

@@ -0,0 +1,106 @@
+import { hasTemplate, renderExplanation, createGenericExplanation, clearTemplates, } from './template-loader.js';
+import { registerAntiPatternTemplates } from './antipattern-explainer.js';
+import { registerBoundaryTemplates, isArchitectureRule } from './boundary-explainer.js';
+import { parseWarningId, findWarningById, findWarningsByRule, getWarningIds, } from '../warnings/warning-id.js';
+import { getPattern } from '../antipattern/patterns.js';
+import { createDebugger } from '../utils/debug.js';
+const debug = createDebugger('explain');
+let templatesInitialised = false;
+function ensureTemplatesInitialised() {
+    if (!templatesInitialised) {
+        clearTemplates();
+        registerAntiPatternTemplates();
+        registerBoundaryTemplates();
+        templatesInitialised = true;
+    }
+}
+export function resetExplainService() {
+    clearTemplates();
+    templatesInitialised = false;
+}
+export function initExplainService() {
+    ensureTemplatesInitialised();
+}
+function buildContext(warning, allWarnings) {
+    const context = {
+        file: warning.location.file,
+        line: warning.location.line,
+        patternName: warning.pattern,
+    };
+    if (allWarnings) {
+        const sameRuleWarnings = findWarningsByRule(allWarnings, warning.id);
+        const sameFileWarnings = sameRuleWarnings.filter((w) => w.location.file === warning.location.file);
+        context.similarCount = sameFileWarnings.length - 1;
+    }
+    return context;
+}
+export function explainWarning(warning, allWarnings) {
+    debug('explaining warning', {
+        id: warning.id,
+        file: warning.location.file,
+        line: warning.location.line,
+    });
+    ensureTemplatesInitialised();
+    const context = buildContext(warning, allWarnings);
+    if (hasTemplate(warning.id)) {
+        const explanation = renderExplanation(warning.id, context);
+        if (explanation) {
+            return explanation;
+        }
+    }
+    return createGenericExplanation(warning.id, warning.title, context);
+}
+export function explainById(warningId, warnings) {
+    debug('explaining by id', warningId);
+    ensureTemplatesInitialised();
+    const parsed = parseWarningId(warningId);
+    if (!parsed) {
+        debug('invalid warning id format', warningId);
+        return null;
+    }
+    const warning = findWarningById(warnings, warningId);
+    if (!warning) {
+        return null;
+    }
+    return explainWarning(warning, warnings);
+}
+export function explainByRule(ruleId, context) {
+    ensureTemplatesInitialised();
+    const fullContext = {
+        file: context?.file ?? 'unknown',
+        line: context?.line ?? 1,
+        ...context,
+    };
+    if (hasTemplate(ruleId)) {
+        return renderExplanation(ruleId, fullContext);
+    }
+    const pattern = getPattern(ruleId);
+    if (pattern) {
+        return renderExplanation(ruleId, fullContext);
+    }
+    if (isArchitectureRule(ruleId)) {
+        return renderExplanation(ruleId, fullContext);
+    }
+    return null;
+}
+export function listWarnings(warnings) {
+    const warningIds = getWarningIds(warnings);
+    return warnings.map((w, i) => ({
+        warningId: warningIds[i],
+        ruleId: w.id,
+        file: w.location.file,
+        line: w.location.line,
+        title: w.title,
+        severity: w.severity,
+    }));
+}
+export function isExplainable(ruleId) {
+    ensureTemplatesInitialised();
+    return hasTemplate(ruleId);
+}
+export function getExplainableRules() {
+    ensureTemplatesInitialised();
+    const antiPatternIds = ['AP-001', 'AP-002', 'AP-003', 'AP-004', 'AP-005', 'AP-006', 'AP-007'];
+    const archIds = ['ARCH-001', 'ARCH-002', 'ARCH-003', 'ARCH-004', 'BOUND-001'];
+    return [...antiPatternIds, ...archIds];
+}

package/dist/explain/index.d.ts

@@ -0,0 +1,7 @@
+export type { ExplanationSection, WarningExplanation, ExplanationContext, ExplanationTemplate, } from './types.js';
+export { ExplanationSectionSchema, WarningExplanationSchema, ExplanationContextSchema, } from './types.js';
+export { registerTemplate, getTemplate, hasTemplate, getRegisteredRuleIds, renderExplanation, clearTemplates, createGenericExplanation, } from './template-loader.js';
+export { registerAntiPatternTemplates, getAntiPatternExplanation, } from './antipattern-explainer.js';
+export { registerBoundaryTemplates, getBoundaryExplanation, isArchitectureRule, } from './boundary-explainer.js';
+export { resetExplainService, initExplainService, explainWarning, explainById, explainByRule, listWarnings, isExplainable, getExplainableRules, type ListWarningsResult, } from './explain-service.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/explain/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/explain/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,kBAAkB,EAClB,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,wBAAwB,EACxB,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,gBAAgB,EAChB,WAAW,EACX,WAAW,EACX,oBAAoB,EACpB,iBAAiB,EACjB,cAAc,EACd,wBAAwB,GACzB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,4BAA4B,EAC5B,yBAAyB,GAC1B,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EACL,yBAAyB,EACzB,sBAAsB,EACtB,kBAAkB,GACnB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,cAAc,EACd,WAAW,EACX,aAAa,EACb,YAAY,EACZ,aAAa,EACb,mBAAmB,EACnB,KAAK,kBAAkB,GACxB,MAAM,sBAAsB,CAAC"}

package/dist/explain/index.js

@@ -0,0 +1,5 @@
+export { ExplanationSectionSchema, WarningExplanationSchema, ExplanationContextSchema, } from './types.js';
+export { registerTemplate, getTemplate, hasTemplate, getRegisteredRuleIds, renderExplanation, clearTemplates, createGenericExplanation, } from './template-loader.js';
+export { registerAntiPatternTemplates, getAntiPatternExplanation, } from './antipattern-explainer.js';
+export { registerBoundaryTemplates, getBoundaryExplanation, isArchitectureRule, } from './boundary-explainer.js';
+export { resetExplainService, initExplainService, explainWarning, explainById, explainByRule, listWarnings, isExplainable, getExplainableRules, } from './explain-service.js';

package/dist/explain/template-loader.d.ts

@@ -0,0 +1,9 @@
+import type { ExplanationTemplate, ExplanationContext, WarningExplanation } from './types.js';
+export declare function registerTemplate(template: ExplanationTemplate): void;
+export declare function getTemplate(ruleId: string): ExplanationTemplate | undefined;
+export declare function hasTemplate(ruleId: string): boolean;
+export declare function getRegisteredRuleIds(): string[];
+export declare function renderExplanation(ruleId: string, context: ExplanationContext): WarningExplanation | null;
+export declare function clearTemplates(): void;
+export declare function createGenericExplanation(ruleId: string, title: string, context: ExplanationContext): WarningExplanation;
+//# sourceMappingURL=template-loader.d.ts.map

package/dist/explain/template-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-loader.d.ts","sourceRoot":"","sources":["../../src/explain/template-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAO9F,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI,CAGpE;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAE3E;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED,wBAAgB,oBAAoB,IAAI,MAAM,EAAE,CAE/C;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,kBAAkB,GAC1B,kBAAkB,GAAG,IAAI,CAO3B;AAED,wBAAgB,cAAc,IAAI,IAAI,CAErC;AAED,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,kBAAkB,GAC1B,kBAAkB,CA0BpB"}

package/dist/explain/template-loader.js

@@ -0,0 +1,51 @@
+import { createDebugger } from '../utils/debug.js';
+const debug = createDebugger('explain');
+const templateRegistry = new Map();
+export function registerTemplate(template) {
+    debug('registering template', template.ruleId);
+    templateRegistry.set(template.ruleId, template);
+}
+export function getTemplate(ruleId) {
+    return templateRegistry.get(ruleId);
+}
+export function hasTemplate(ruleId) {
+    return templateRegistry.has(ruleId);
+}
+export function getRegisteredRuleIds() {
+    return Array.from(templateRegistry.keys());
+}
+export function renderExplanation(ruleId, context) {
+    const template = templateRegistry.get(ruleId);
+    if (!template) {
+        debug('no template found for rule', ruleId);
+        return null;
+    }
+    return template.render(context);
+}
+export function clearTemplates() {
+    templateRegistry.clear();
+}
+export function createGenericExplanation(ruleId, title, context) {
+    return {
+        ruleId,
+        title,
+        summary: `Warning ${ruleId} detected at ${context.file}:${context.line}`,
+        whyItMatters: {
+            title: 'WHY THIS WARNING EXISTS',
+            content: 'This warning indicates a potential issue in your code. ' +
+                'Please refer to the warning message for specific details.',
+        },
+        howToAddress: {
+            title: 'HOW TO ADDRESS',
+            content: 'Review the flagged code and consider the warning message. ' +
+                'Determine if changes are needed based on your project requirements.',
+        },
+        whenToSuppress: {
+            title: 'WHEN TO SUPPRESS',
+            content: 'Suppress only if you understand the warning and have a valid reason. ' +
+                'Use: // @anvil-ignore ' +
+                ruleId +
+                ': [your reason]',
+        },
+    };
+}

package/dist/explain/types.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+export declare const ExplanationSectionSchema: z.ZodObject<{
+    title: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+export type ExplanationSection = z.infer<typeof ExplanationSectionSchema>;
+export declare const WarningExplanationSchema: z.ZodObject<{
+    ruleId: z.ZodString;
+    title: z.ZodString;
+    summary: z.ZodString;
+    whyItMatters: z.ZodObject<{
+        title: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>;
+    howToAddress: z.ZodObject<{
+        title: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>;
+    whenToSuppress: z.ZodObject<{
+        title: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>;
+    related: z.ZodOptional<z.ZodObject<{
+        documentation: z.ZodOptional<z.ZodString>;
+        ruleDefinition: z.ZodOptional<z.ZodString>;
+        similarWarnings: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type WarningExplanation = z.infer<typeof WarningExplanationSchema>;
+export declare const ExplanationContextSchema: z.ZodObject<{
+    file: z.ZodString;
+    line: z.ZodNumber;
+    code: z.ZodOptional<z.ZodString>;
+    fromFile: z.ZodOptional<z.ZodString>;
+    toFile: z.ZodOptional<z.ZodString>;
+    fromLayer: z.ZodOptional<z.ZodString>;
+    toLayer: z.ZodOptional<z.ZodString>;
+    patternName: z.ZodOptional<z.ZodString>;
+    similarCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ExplanationContext = z.infer<typeof ExplanationContextSchema>;
+export interface ExplanationTemplate {
+    ruleId: string;
+    render(context: ExplanationContext): WarningExplanation;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/explain/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/explain/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,wBAAwB;;;iBAGnC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;iBAcnC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,wBAAwB;;;;;;;;;;iBAUnC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,OAAO,EAAE,kBAAkB,GAAG,kBAAkB,CAAC;CACzD"}

package/dist/explain/types.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export const ExplanationSectionSchema = z.object({
+    title: z.string().describe('Section title (e.g., "WHY THIS WARNING EXISTS")'),
+    content: z.string().describe('Section content, may contain placeholders'),
+});
+export const WarningExplanationSchema = z.object({
+    ruleId: z.string().describe('Rule ID (e.g., AP-003, ARCH-001)'),
+    title: z.string().describe('Warning title'),
+    summary: z.string().describe('One-line summary of the warning'),
+    whyItMatters: ExplanationSectionSchema.describe('Why this warning exists'),
+    howToAddress: ExplanationSectionSchema.describe('How to fix or address'),
+    whenToSuppress: ExplanationSectionSchema.describe('When suppression is appropriate'),
+    related: z
+        .object({
+        documentation: z.string().optional(),
+        ruleDefinition: z.string().optional(),
+        similarWarnings: z.number().int().nonnegative().optional(),
+    })
+        .optional(),
+});
+export const ExplanationContextSchema = z.object({
+    file: z.string().describe('File path where warning occurred'),
+    line: z.number().int().positive().describe('Line number'),
+    code: z.string().optional().describe('Source code snippet at the location'),
+    fromFile: z.string().optional().describe('Source file (for boundary violations)'),
+    toFile: z.string().optional().describe('Target file (for boundary violations)'),
+    fromLayer: z.string().optional().describe('Source layer (for boundary violations)'),
+    toLayer: z.string().optional().describe('Target layer (for boundary violations)'),
+    patternName: z.string().optional().describe('Pattern name (for anti-patterns)'),
+    similarCount: z.number().int().nonnegative().optional(),
+});

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @eddacraft/anvil-core
+ *
+ * Core domain logic for the Anvil system.
+ * Contains antipattern detection, architecture analysis, drift detection,
+ * suppression management, validation, and other core functionality.
+ *
+ * Note: Some modules perform filesystem I/O (provenance, drift snapshots,
+ * architecture baseline, suppression store). Heavy I/O orchestration
+ * (gate runner, caching, OPA execution) lives in @eddacraft/anvil-runtime.
+ *
+ * @module @eddacraft/anvil-core
+ */
+export * from './contracts/index.js';
+export * from './config/index.js';
+export * from './antipattern/index.js';
+export * from './suppression/index.js';
+export * from './architecture/index.js';
+export * from './drift/index.js';
+export * from './provenance/index.js';
+export * from './warnings/index.js';
+export * from './explain/index.js';
+export * from './validation/index.js';
+export * from './crypto/index.js';
+export * from './utils/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,cAAc,sBAAsB,CAAC;AAGrC,cAAc,mBAAmB,CAAC;AAGlC,cAAc,wBAAwB,CAAC;AAGvC,cAAc,wBAAwB,CAAC;AAGvC,cAAc,yBAAyB,CAAC;AAGxC,cAAc,kBAAkB,CAAC;AAGjC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,mBAAmB,CAAC;AAGlC,cAAc,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,37 @@
+/**
+ * @eddacraft/anvil-core
+ *
+ * Core domain logic for the Anvil system.
+ * Contains antipattern detection, architecture analysis, drift detection,
+ * suppression management, validation, and other core functionality.
+ *
+ * Note: Some modules perform filesystem I/O (provenance, drift snapshots,
+ * architecture baseline, suppression store). Heavy I/O orchestration
+ * (gate runner, caching, OPA execution) lives in @eddacraft/anvil-runtime.
+ *
+ * @module @eddacraft/anvil-core
+ */
+// Contracts (schemas, types, events) — formerly @eddacraft/anvil-contracts
+export * from './contracts/index.js';
+// Platform config — formerly @eddacraft/anvil-platform-config
+export * from './config/index.js';
+// Antipattern detection
+export * from './antipattern/index.js';
+// Suppression management
+export * from './suppression/index.js';
+// Architecture analysis
+export * from './architecture/index.js';
+// Drift detection
+export * from './drift/index.js';
+// Provenance tracking
+export * from './provenance/index.js';
+// Warning utilities
+export * from './warnings/index.js';
+// Explain functionality
+export * from './explain/index.js';
+// Validation
+export * from './validation/index.js';
+// Crypto utilities
+export * from './crypto/index.js';
+// General utilities
+export * from './utils/index.js';