arkgate 2.13.0 → 3.0.1

package/dist/configContract-BxSIwVRo.d.ts

@@ -0,0 +1,259 @@
+/**
+ * Canonical, pure contract for ark.config.json.
+ *
+ * Tooling adapters own filesystem I/O; this module owns JSON parsing, deterministic
+ * migration, defaults, validation, diagnostics, and the published JSON Schema.
+ * The standalone CLI artifact is generated into bin/lib/config-contract.mjs.
+ */
+declare const ARK_CONFIG_SCHEMA_VERSION: "1.0";
+type ArkConfigCyclePolicy = 'strict' | 'soft' | 'framework-soft' | 'off';
+type ArkConfigLayer = {
+    name: string;
+    patterns: string[];
+    exclude?: string[];
+    intentPrefixes?: string[];
+    description?: string;
+    forbiddenGlobals?: string[];
+    mayImportInfrastructure?: boolean;
+    optional?: boolean;
+};
+type ArkConfigRule = {
+    from: string;
+    to: string;
+    allowed: boolean;
+    message?: string;
+    peerIsolation?: boolean;
+    sliceFolders?: string[];
+};
+type ArkConfigSafety = {
+    maxTsSuppressions?: number;
+    maxAnyCasts?: number;
+    allowInMemory?: boolean;
+    allowDisabledPeerIsolation?: boolean;
+};
+type ArkConfig = {
+    $schema: string;
+    schemaVersion: typeof ARK_CONFIG_SCHEMA_VERSION;
+    name?: string;
+    include: string[];
+    exclude?: string[];
+    excludeGenerated?: boolean;
+    frameworkOverlay?: string;
+    layers: ArkConfigLayer[];
+    rules: ArkConfigRule[];
+    cyclePolicy?: ArkConfigCyclePolicy;
+    dynamicImportAllowlist?: string[];
+    safety?: ArkConfigSafety;
+};
+declare const ARK_CONFIG_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://unpkg.com/arkgate@2/schemas/ark.config.schema.json";
+    readonly title: "ArkGate architecture contract";
+    readonly description: "Versioned contract consumed identically by ArkGate CLI, MCP, and ESLint surfaces.";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["$schema", "schemaVersion", "include", "layers", "rules"];
+    readonly properties: {
+        readonly $schema: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly default: "https://unpkg.com/arkgate@2/schemas/ark.config.schema.json";
+            readonly description: "Editor-facing URL or local path for this JSON Schema.";
+        };
+        readonly schemaVersion: {
+            readonly type: "string";
+            readonly const: "1.0";
+            readonly default: "1.0";
+        };
+        readonly name: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly include: {
+            readonly minItems: 1;
+            readonly default: readonly ["src"];
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly uniqueItems: true;
+        };
+        readonly exclude: {
+            readonly default: readonly [];
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly uniqueItems: true;
+        };
+        readonly excludeGenerated: {
+            readonly type: "boolean";
+            readonly default: true;
+        };
+        readonly frameworkOverlay: {
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly layers: {
+            readonly type: "array";
+            readonly default: readonly [];
+            readonly items: {
+                readonly $ref: "#/$defs/layer";
+            };
+        };
+        readonly rules: {
+            readonly type: "array";
+            readonly default: ArkConfigRule[];
+            readonly items: {
+                readonly $ref: "#/$defs/rule";
+            };
+        };
+        readonly cyclePolicy: {
+            readonly type: "string";
+            readonly enum: readonly ["strict", "soft", "framework-soft", "off"];
+            readonly default: "strict";
+        };
+        readonly dynamicImportAllowlist: {
+            readonly default: readonly [];
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+            readonly uniqueItems: true;
+        };
+        readonly safety: {
+            readonly $ref: "#/$defs/safety";
+            readonly default: {
+                readonly maxTsSuppressions: 0;
+                readonly maxAnyCasts: 0;
+                readonly allowInMemory: false;
+                readonly allowDisabledPeerIsolation: false;
+            };
+        };
+    };
+    readonly $defs: {
+        readonly layer: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["name", "patterns"];
+            readonly properties: {
+                readonly name: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly patterns: {
+                    readonly minItems: 1;
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly uniqueItems: true;
+                };
+                readonly exclude: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly uniqueItems: true;
+                };
+                readonly intentPrefixes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly uniqueItems: true;
+                };
+                readonly description: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly forbiddenGlobals: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly uniqueItems: true;
+                };
+                readonly mayImportInfrastructure: {
+                    readonly type: "boolean";
+                };
+                readonly optional: {
+                    readonly type: "boolean";
+                };
+            };
+        };
+        readonly rule: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["from", "to", "allowed"];
+            readonly properties: {
+                readonly from: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly to: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly allowed: {
+                    readonly type: "boolean";
+                };
+                readonly message: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly peerIsolation: {
+                    readonly type: "boolean";
+                };
+                readonly sliceFolders: {
+                    readonly minItems: 1;
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly uniqueItems: true;
+                };
+            };
+        };
+        readonly safety: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly maxTsSuppressions: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly default: 0;
+                };
+                readonly maxAnyCasts: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly default: 0;
+                };
+                readonly allowInMemory: {
+                    readonly type: "boolean";
+                    readonly default: false;
+                };
+                readonly allowDisabledPeerIsolation: {
+                    readonly type: "boolean";
+                    readonly default: false;
+                };
+            };
+        };
+    };
+};
+type ArkConfigLoadResult = {
+    config: ArkConfig;
+    migratedFrom: 'unversioned' | null;
+};
+declare function loadArkConfigContract(input: unknown, source?: string): ArkConfigLoadResult;
+declare function parseArkConfigJson(json: string, source?: string): ArkConfigLoadResult;
+
+export { type ArkConfig as A, type ArkConfigRule as a, type ArkConfigLayer as b, type ArkConfigLoadResult as c, ARK_CONFIG_SCHEMA as d, ARK_CONFIG_SCHEMA_VERSION as e, loadArkConfigContract as l, parseArkConfigJson as p };

package/dist/eslint/index.cjs

@@ -521,6 +521,63 @@ function parseArkConfigJson(json, source = "ark.config.json") {
   return loadArkConfigContract(input, source);
 }
 
+// src/domain/adapterContract.ts
+function text(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function positiveInteger(value, fallback) {
+  return Number.isInteger(value) && Number(value) > 0 ? Number(value) : fallback;
+}
+function toAdapterDiagnostic(violation, fallbackSeverity = "error") {
+  const ruleId = text(violation.ruleId) ?? text(violation.code) ?? "ARK_UNKNOWN";
+  const severity = violation.severity === "warning" ? "warning" : fallbackSeverity;
+  const evidence = {
+    ...text(violation.target) ? { target: text(violation.target) } : {},
+    ...text(violation.fromLayer) ? { fromLayer: text(violation.fromLayer) } : {},
+    ...text(violation.toLayer) ? { toLayer: text(violation.toLayer) } : {},
+    ...typeof violation.typeOnly === "boolean" ? { typeOnly: violation.typeOnly } : {}
+  };
+  return {
+    ruleId,
+    severity,
+    message: text(violation.message) ?? ruleId,
+    location: {
+      file: text(violation.file) ?? "<unknown>",
+      line: positiveInteger(violation.line, 1),
+      column: positiveInteger(violation.column, 1)
+    },
+    evidence
+  };
+}
+
+// src/domain/sourcePolicy.ts
+var SOURCE_POLICY_MESSAGES = {
+  RAW_EVENT_PUBLISH: "Publish through a registered intent creator; raw event objects or intent strings bypass Ark contracts and tooling.",
+  PUBLISH_MISSING_SOURCE: "Strict Ark publish calls must include metadata.source."
+};
+function looksLikeArkIntent(value) {
+  return /^(Domain|Application|Adapter|Workflow|Job|Presentation|Reporting|Metadata|Security|Audit|Observability|Kernel)\.[A-Za-z0-9_.]+$/.test(
+    value
+  );
+}
+function classifyPublishFacts(facts) {
+  if (!facts.publishCall) return [];
+  const findings = [];
+  if (facts.rawIntentName !== void 0 && looksLikeArkIntent(facts.rawIntentName) || facts.objectHasIntent) {
+    findings.push({
+      ruleId: "RAW_EVENT_PUBLISH",
+      message: SOURCE_POLICY_MESSAGES.RAW_EVENT_PUBLISH
+    });
+  }
+  if (facts.arkPublishCandidate && !facts.hasSource) {
+    findings.push({
+      ruleId: "PUBLISH_MISSING_SOURCE",
+      message: SOURCE_POLICY_MESSAGES.PUBLISH_MISSING_SOURCE
+    });
+  }
+  return findings;
+}
+
 // src/eslint/index.ts
 function lintedFilename(context) {
   if (typeof context.physicalFilename === "string" && context.physicalFilename.length > 0) {
@@ -538,6 +595,15 @@ function lintedFilename(context) {
   }
   return "";
 }
+function reportAdapterDiagnostic(context, node, messageId, violation, data) {
+  const diagnostic = toAdapterDiagnostic({
+    ...violation,
+    line: violation.line ?? node.loc?.start?.line,
+    column: violation.column ?? (typeof node.loc?.start?.column === "number" ? node.loc.start.column + 1 : void 0)
+  });
+  context.report({ node, messageId, ...data ? { data } : {}, diagnostic });
+  return diagnostic;
+}
 function findConfigPath(startFile) {
   if (!startFile || startFile === "<input>" || startFile.startsWith("stdin")) return null;
   let dir = import_node_path.default.dirname(import_node_path.default.resolve(startFile));
@@ -639,38 +705,14 @@ function objectHasMetadataSource(node) {
   const metadata = objectProperty(node, "metadata")?.value;
   return objectHasProperty(metadata, "source");
 }
-function looksLikeIntent(value) {
-  return /^(Domain|Application|Adapter|Workflow|Job|Presentation|Reporting|Metadata|Security|Audit|Observability|Kernel)\.[A-Za-z0-9_.]+$/.test(
-    value
-  );
-}
 function isPublishCall(node) {
   return calleePropertyName(node) === "publish";
 }
-function isDomainFileHeuristic(filename) {
-  const normalized = filename.split("\\").join("/").toLowerCase();
-  return normalized.includes("/domain/") || normalized.endsWith("/domain.ts");
-}
-function isInfraImportHeuristic(specifier) {
-  const normalized = specifier.toLowerCase();
-  return [
-    "adapter",
-    "adapters",
-    "infrastructure",
-    "persistence",
-    "repository",
-    "repositories",
-    "integration",
-    "database",
-    "db"
-  ].some((token) => normalized.includes(token));
-}
-var DEFAULT_FORBIDDEN_GLOBALS = ["fetch", "process", "Date.now", "Math.random"];
 var noDomainInfraImports = {
   meta: {
     type: "problem",
     docs: {
-      description: "Disallow imports that violate ark.config.json layer rules (same contract as arkgate-check). Falls back to domain\u2192infra path heuristics when no config is found."
+      description: "Disallow imports that violate ark.config.json layer rules (same contract as arkgate-check)."
     },
     messages: {
       forbiddenImport: "Architecture: {{fromLayer}} must not import {{toLayer}} (ark.config.json). Specifier: {{specifier}}",
@@ -702,17 +744,24 @@ var noDomainInfraImports = {
           toPath: relTarget,
           layers: config.layers
         })) {
-          context.report({
+          reportAdapterDiagnostic(
+            context,
             node,
-            messageId: "forbiddenImport",
-            data: { fromLayer, toLayer, specifier: source }
-          });
+            "forbiddenImport",
+            {
+              ruleId: "LAYER_IMPORT_VIOLATION",
+              file: relFile,
+              fromLayer,
+              toLayer,
+              target: relTarget,
+              ...node.importKind === "type" ? { typeOnly: true } : {},
+              message: `${fromLayer} must not import ${toLayer}.`
+            },
+            { fromLayer, toLayer, specifier: source }
+          );
         }
         return;
       }
-      if (isDomainFileHeuristic(filename) && isInfraImportHeuristic(source)) {
-        context.report({ node, messageId: "forbiddenImportHeuristic" });
-      }
     };
     return {
       ImportDeclaration: check,
@@ -735,11 +784,21 @@ var noRawEventPublish = {
   create(context) {
     return {
       CallExpression(node) {
-        if (!isPublishCall(node)) return;
         const firstArg = node.arguments?.[0];
         const firstValue = stringValue(firstArg);
-        if (firstValue && looksLikeIntent(firstValue) || objectHasProperty(firstArg, "intent")) {
-          context.report({ node, messageId: "rawPublish" });
+        const findings = classifyPublishFacts({
+          publishCall: isPublishCall(node),
+          rawIntentName: firstValue,
+          objectHasIntent: objectHasProperty(firstArg, "intent"),
+          arkPublishCandidate: false,
+          hasSource: true
+        });
+        if (findings.some((finding) => finding.ruleId === "RAW_EVENT_PUBLISH")) {
+          const finding = findings.find((item) => item.ruleId === "RAW_EVENT_PUBLISH");
+          reportAdapterDiagnostic(context, node, "rawPublish", {
+            ...finding,
+            file: lintedFilename(context)
+          });
         }
       }
     };
@@ -759,13 +818,22 @@ var requirePublishSource = {
   create(context) {
     return {
       CallExpression(node) {
-        if (!isPublishCall(node)) return;
         const firstArg = node.arguments?.[0];
         const metadataArg = node.arguments?.[2];
-        if (objectHasMetadataSource(firstArg) || objectHasProperty(metadataArg, "source")) {
-          return;
+        const findings = classifyPublishFacts({
+          publishCall: isPublishCall(node),
+          rawIntentName: stringValue(firstArg),
+          objectHasIntent: objectHasProperty(firstArg, "intent"),
+          arkPublishCandidate: true,
+          hasSource: objectHasMetadataSource(firstArg) || objectHasProperty(metadataArg, "source")
+        });
+        const finding = findings.find((item) => item.ruleId === "PUBLISH_MISSING_SOURCE");
+        if (finding) {
+          reportAdapterDiagnostic(context, node, "missingSource", {
+            ...finding,
+            file: lintedFilename(context)
+          });
         }
-        context.report({ node, messageId: "missingSource" });
       }
     };
   }
@@ -774,7 +842,7 @@ var noForbiddenGlobals = {
   meta: {
     type: "problem",
     docs: {
-      description: "Disallow ambient globals from the layer\u2019s forbiddenGlobals in ark.config.json (same purity surface as arkgate-check). Option `globals` overrides. Without config, defaults apply only on domain-like paths."
+      description: "Disallow ambient globals from the layer\u2019s forbiddenGlobals in ark.config.json (same purity surface as ark-check). Option `globals` explicitly overrides."
     },
     messages: {
       forbiddenGlobal: 'Ambient global "{{name}}" is forbidden in {{layer}} (ark.config.json); inject the capability through a port instead.',
@@ -812,18 +880,28 @@ var noForbiddenGlobals = {
       } else {
         globals = null;
       }
-    } else if (isDomainFileHeuristic(filename)) {
-      globals = new Set(DEFAULT_FORBIDDEN_GLOBALS);
     }
     if (!globals) {
       return {};
     }
     const scopeAware = typeof sourceCodeFor(context)?.getScope === "function";
-    const report = (node, name) => context.report({
-      node,
-      messageId: config ? "forbiddenGlobal" : "forbiddenGlobalDefault",
-      data: { name, layer: layerName }
-    });
+    const report = (node, name) => {
+      const absFile = import_node_path.default.isAbsolute(filename) ? filename : import_node_path.default.resolve(filename);
+      const reportFile = root ? import_node_path.default.relative(root, absFile).split(import_node_path.default.sep).join("/") : filename;
+      reportAdapterDiagnostic(
+        context,
+        node,
+        config ? "forbiddenGlobal" : "forbiddenGlobalDefault",
+        {
+          ruleId: "FORBIDDEN_GLOBAL",
+          file: reportFile,
+          fromLayer: layerName,
+          target: name,
+          message: `${layerName} must not use the ambient global "${name}".`
+        },
+        { name, layer: layerName }
+      );
+    };
     return {
       MemberExpression(node) {
         if (node.parent?.type === "MemberExpression" && node.parent.object === node) return;
@@ -897,4 +975,3 @@ var eslint_default = plugin;
   requirePublishSource,
   resolveRelativeImport
 });
-//# sourceMappingURL=index.cjs.map

package/dist/eslint/index.d.cts

@@ -1,4 +1,4 @@
-import { A as ArkConfig } from '../configContract-iBLxx5Tz.cjs';
+import { A as ArkConfig } from '../configContract-BxSIwVRo.cjs';
 
 /**
  * Pure layer-glob matching for ark.config.json.
@@ -103,6 +103,12 @@ type AstNode = {
     parent?: AstNode;
     init?: AstNode;
     computed?: boolean;
+    loc?: {
+        start?: {
+            line?: number;
+            column?: number;
+        };
+    };
 };
 type ArkRule = {
     meta: {

package/dist/eslint/index.d.ts

@@ -1,4 +1,4 @@
-import { A as ArkConfig } from '../configContract-iBLxx5Tz.js';
+import { A as ArkConfig } from '../configContract-BxSIwVRo.js';
 
 /**
  * Pure layer-glob matching for ark.config.json.
@@ -103,6 +103,12 @@ type AstNode = {
     parent?: AstNode;
     init?: AstNode;
     computed?: boolean;
+    loc?: {
+        start?: {
+            line?: number;
+            column?: number;
+        };
+    };
 };
 type ArkRule = {
     meta: {