@webpieces/rules-sdk 0.0.0-stage → 0.4.846

package/package.json

@@ -1,6 +1,29 @@
 {
   "name": "@webpieces/rules-sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.4.846",
+  "description": "Pure schema and rule pack value contracts.",
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src/**/*",
+    "README.md"
+  ],
+  "dependencies": {
+    "tslib": "2.8.1"
+  },
+  "author": "Dean Hiller",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/deanhiller/webpieces-ts.git",
+    "directory": "packages/tooling/rules-sdk"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "types": "./src/index.d.ts"
 }

package/src/base-rule-config.d.ts

@@ -0,0 +1,10 @@
+import { FieldDef } from './field-def';
+export declare abstract class BaseRuleConfig {
+    mode?: string;
+    turnOffRuleUntilEpoch?: number;
+    turnOffRuleWhileOnBranch?: string | null;
+}
+export declare const BASE_RULE_SCHEMA: {
+    turnOffRuleUntilEpoch: FieldDef;
+    turnOffRuleWhileOnBranch: FieldDef;
+};

package/src/base-rule-config.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BASE_RULE_SCHEMA = exports.BaseRuleConfig = void 0;
+const field_def_1 = require("./field-def");
+class BaseRuleConfig {
+    // `mode` is declared here (loosely typed) so the shared AbstractRule base can read it for
+    // on/off. Each concrete *Config narrows it to its own union (e.g. `mode?: ModifiedCodeMode`),
+    // which is an assignable (covariant) override.
+    mode;
+    // TS-optional, but schema-REQUIRED (see BASE_RULE_SCHEMA) — same split as `mode`. Read directly by
+    // AbstractRule.shouldRun, RuleGate, and the code-rules validators.
+    turnOffRuleUntilEpoch;
+    turnOffRuleWhileOnBranch;
+}
+exports.BaseRuleConfig = BaseRuleConfig;
+exports.BASE_RULE_SCHEMA = {
+    turnOffRuleUntilEpoch: new field_def_1.FieldDef('number'),
+    turnOffRuleWhileOnBranch: field_def_1.FieldDef.nullableString(),
+};
+//# sourceMappingURL=base-rule-config.js.map

package/src/base-rule-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-rule-config.js","sourceRoot":"","sources":["../../../../../packages/tooling/rules-sdk/src/base-rule-config.ts"],"names":[],"mappings":";;;AAAA,2CAAuC;AAEvC,MAAsB,cAAc;IAChC,0FAA0F;IAC1F,8FAA8F;IAC9F,+CAA+C;IAC/C,IAAI,CAAU;IACd,mGAAmG;IACnG,mEAAmE;IACnE,qBAAqB,CAAU;IAC/B,wBAAwB,CAAiB;CAC5C;AATD,wCASC;AAEY,QAAA,gBAAgB,GAAG;IAC5B,qBAAqB,EAAE,IAAI,oBAAQ,CAAC,QAAQ,CAAC;IAC7C,wBAAwB,EAAE,oBAAQ,CAAC,cAAc,EAAE;CACtD,CAAC","sourcesContent":["import { FieldDef } from './field-def';\n\nexport abstract class BaseRuleConfig {\n    // `mode` is declared here (loosely typed) so the shared AbstractRule base can read it for\n    // on/off. Each concrete *Config narrows it to its own union (e.g. `mode?: ModifiedCodeMode`),\n    // which is an assignable (covariant) override.\n    mode?: string;\n    // TS-optional, but schema-REQUIRED (see BASE_RULE_SCHEMA) — same split as `mode`. Read directly by\n    // AbstractRule.shouldRun, RuleGate, and the code-rules validators.\n    turnOffRuleUntilEpoch?: number;\n    turnOffRuleWhileOnBranch?: string | null;\n}\n\nexport const BASE_RULE_SCHEMA = {\n    turnOffRuleUntilEpoch: new FieldDef('number'),\n    turnOffRuleWhileOnBranch: FieldDef.nullableString(),\n};\n\n"]}

package/src/field-def.d.ts

@@ -0,0 +1,24 @@
+type FieldType = 'string' | 'number' | 'boolean' | 'string[]' | 'object[]';
+export declare class FieldDef {
+    readonly type: FieldType;
+    readonly enumValues?: readonly string[] | undefined;
+    readonly optional: boolean;
+    readonly nullable: boolean;
+    readonly nonEmpty: boolean;
+    readonly elementSchema?: Readonly<Record<string, FieldDef>> | undefined;
+    constructor(type: FieldType, enumValues?: readonly string[] | undefined, optional?: boolean, nullable?: boolean, nonEmpty?: boolean, elementSchema?: Readonly<Record<string, FieldDef>> | undefined);
+    /** Marks a field as optional (omittable) in the config schema. */
+    static optional(type: FieldType, enumValues?: readonly string[]): FieldDef;
+    /** A REQUIRED string field that also accepts `null` (present-but-unset). */
+    static nullableString(): FieldDef;
+    /** A REQUIRED `string[]` that must hold at least one string. */
+    static nonEmptyStrings(): FieldDef;
+    /** A REQUIRED list of objects (possibly empty), each validated against `elementSchema`. */
+    static objects(elementSchema: Readonly<Record<string, FieldDef>>): FieldDef;
+    /** A REQUIRED, non-empty list of objects, each validated against `elementSchema`. */
+    static nonEmptyObjects(elementSchema: Readonly<Record<string, FieldDef>>): FieldDef;
+}
+export type SchemaShape<T> = {
+    [K in keyof Required<T>]: FieldDef;
+};
+export {};

package/src/field-def.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldDef = void 0;
+class FieldDef {
+    type;
+    enumValues;
+    optional;
+    nullable;
+    nonEmpty;
+    elementSchema;
+    constructor(type, enumValues, 
+    // When true, the field is omittable: the missing-rule snippet lists it
+    // as optional rather than as a required copy-paste field.
+    optional = false, 
+    // When true, JSON `null` is an accepted value in addition to `type`. Used for a REQUIRED
+    // field whose "unset" state must still be visible in the config (e.g. turnOffRuleWhileOnBranch:
+    // null means "no branch / always on") — required so it is always present, nullable so it can be
+    // present-but-unset without inventing a sentinel string.
+    nullable = false, 
+    // When true, an array field (`string[]` / `object[]`) must hold at least one element — for a list
+    // whose emptiness would mean "judge nothing" while reading as "configured".
+    nonEmpty = false, 
+    // For `object[]` only: the schema EVERY element is validated against (unknown keys, missing
+    // required keys, types, non-emptiness), exactly like a rule entry's own fields.
+    elementSchema) {
+        this.type = type;
+        this.enumValues = enumValues;
+        this.optional = optional;
+        this.nullable = nullable;
+        this.nonEmpty = nonEmpty;
+        this.elementSchema = elementSchema;
+    }
+    /** Marks a field as optional (omittable) in the config schema. */
+    // webpieces-disable no-function-outside-class -- pure schema value factory, matching the sibling FieldDef factories; the SDK intentionally has no DI
+    static optional(type, enumValues) {
+        return new FieldDef(type, enumValues, true);
+    }
+    /** A REQUIRED string field that also accepts `null` (present-but-unset). */
+    // webpieces-disable no-function-outside-class -- static factory, matches sibling FieldDef.optional
+    static nullableString() {
+        return new FieldDef('string', undefined, false, true);
+    }
+    /** A REQUIRED `string[]` that must hold at least one string. */
+    // webpieces-disable no-function-outside-class -- static factory, matches sibling FieldDef.optional
+    static nonEmptyStrings() {
+        return new FieldDef('string[]', undefined, false, false, true);
+    }
+    /** A REQUIRED list of objects (possibly empty), each validated against `elementSchema`. */
+    // webpieces-disable no-function-outside-class -- static factory, matches sibling FieldDef.optional
+    static objects(elementSchema) {
+        return new FieldDef('object[]', undefined, false, false, false, elementSchema);
+    }
+    /** A REQUIRED, non-empty list of objects, each validated against `elementSchema`. */
+    // webpieces-disable no-function-outside-class -- static factory, matches sibling FieldDef.optional
+    static nonEmptyObjects(elementSchema) {
+        return new FieldDef('object[]', undefined, false, false, true, elementSchema);
+    }
+}
+exports.FieldDef = FieldDef;
+//# sourceMappingURL=field-def.js.map

package/src/field-def.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-def.js","sourceRoot":"","sources":["../../../../../packages/tooling/rules-sdk/src/field-def.ts"],"names":[],"mappings":";;;AAIA,MAAa,QAAQ;IAEJ;IACA;IAGA;IAKA;IAGA;IAGA;IAhBb,YACa,IAAe,EACf,UAA8B;IACvC,uEAAuE;IACvE,0DAA0D;IACjD,WAAoB,KAAK;IAClC,yFAAyF;IACzF,gGAAgG;IAChG,gGAAgG;IAChG,yDAAyD;IAChD,WAAoB,KAAK;IAClC,kGAAkG;IAClG,4EAA4E;IACnE,WAAoB,KAAK;IAClC,4FAA4F;IAC5F,gFAAgF;IACvE,aAAkD;QAflD,SAAI,GAAJ,IAAI,CAAW;QACf,eAAU,GAAV,UAAU,CAAoB;QAG9B,aAAQ,GAAR,QAAQ,CAAiB;QAKzB,aAAQ,GAAR,QAAQ,CAAiB;QAGzB,aAAQ,GAAR,QAAQ,CAAiB;QAGzB,kBAAa,GAAb,aAAa,CAAqC;IAC5D,CAAC;IAEJ,kEAAkE;IAClE,qJAAqJ;IACrJ,MAAM,CAAC,QAAQ,CAAC,IAAe,EAAE,UAA8B;QAC3D,OAAO,IAAI,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC;IAChD,CAAC;IAED,4EAA4E;IAC5E,mGAAmG;IACnG,MAAM,CAAC,cAAc;QACjB,OAAO,IAAI,QAAQ,CAAC,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;IAC1D,CAAC;IAED,gEAAgE;IAChE,mGAAmG;IACnG,MAAM,CAAC,eAAe;QAClB,OAAO,IAAI,QAAQ,CAAC,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;IACnE,CAAC;IAED,2FAA2F;IAC3F,mGAAmG;IACnG,MAAM,CAAC,OAAO,CAAC,aAAiD;QAC5D,OAAO,IAAI,QAAQ,CAAC,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC;IACnF,CAAC;IAED,qFAAqF;IACrF,mGAAmG;IACnG,MAAM,CAAC,eAAe,CAAC,aAAiD;QACpE,OAAO,IAAI,QAAQ,CAAC,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC;IAClF,CAAC;CACJ;AAjDD,4BAiDC","sourcesContent":["// `object[]` is a list of JSON objects, each validated against the field's `elementSchema` (e.g.\n// required-type-suffix's `entries`: `[{ \"paths\": [...], \"suffixes\": [...] }]`).\ntype FieldType = 'string' | 'number' | 'boolean' | 'string[]' | 'object[]';\n\nexport class FieldDef {\n    constructor(\n        readonly type: FieldType,\n        readonly enumValues?: readonly string[],\n        // When true, the field is omittable: the missing-rule snippet lists it\n        // as optional rather than as a required copy-paste field.\n        readonly optional: boolean = false,\n        // When true, JSON `null` is an accepted value in addition to `type`. Used for a REQUIRED\n        // field whose \"unset\" state must still be visible in the config (e.g. turnOffRuleWhileOnBranch:\n        // null means \"no branch / always on\") — required so it is always present, nullable so it can be\n        // present-but-unset without inventing a sentinel string.\n        readonly nullable: boolean = false,\n        // When true, an array field (`string[]` / `object[]`) must hold at least one element — for a list\n        // whose emptiness would mean \"judge nothing\" while reading as \"configured\".\n        readonly nonEmpty: boolean = false,\n        // For `object[]` only: the schema EVERY element is validated against (unknown keys, missing\n        // required keys, types, non-emptiness), exactly like a rule entry's own fields.\n        readonly elementSchema?: Readonly<Record<string, FieldDef>>,\n    ) {}\n\n    /** Marks a field as optional (omittable) in the config schema. */\n    // webpieces-disable no-function-outside-class -- pure schema value factory, matching the sibling FieldDef factories; the SDK intentionally has no DI\n    static optional(type: FieldType, enumValues?: readonly string[]): FieldDef {\n        return new FieldDef(type, enumValues, true);\n    }\n\n    /** A REQUIRED string field that also accepts `null` (present-but-unset). */\n    // webpieces-disable no-function-outside-class -- static factory, matches sibling FieldDef.optional\n    static nullableString(): FieldDef {\n        return new FieldDef('string', undefined, false, true);\n    }\n\n    /** A REQUIRED `string[]` that must hold at least one string. */\n    // webpieces-disable no-function-outside-class -- static factory, matches sibling FieldDef.optional\n    static nonEmptyStrings(): FieldDef {\n        return new FieldDef('string[]', undefined, false, false, true);\n    }\n\n    /** A REQUIRED list of objects (possibly empty), each validated against `elementSchema`. */\n    // webpieces-disable no-function-outside-class -- static factory, matches sibling FieldDef.optional\n    static objects(elementSchema: Readonly<Record<string, FieldDef>>): FieldDef {\n        return new FieldDef('object[]', undefined, false, false, false, elementSchema);\n    }\n\n    /** A REQUIRED, non-empty list of objects, each validated against `elementSchema`. */\n    // webpieces-disable no-function-outside-class -- static factory, matches sibling FieldDef.optional\n    static nonEmptyObjects(elementSchema: Readonly<Record<string, FieldDef>>): FieldDef {\n        return new FieldDef('object[]', undefined, false, false, true, elementSchema);\n    }\n}\n\n// Enforces that a static SCHEMA has exactly the same keys as the config class.\n// Add a field to the class → TS errors until SCHEMA is updated.\n// Add to SCHEMA without adding to class → TS errors (extra property).\nexport type SchemaShape<T> = { [K in keyof Required<T>]: FieldDef };\n"]}

package/src/index.d.ts

@@ -0,0 +1,9 @@
+export { FieldDef } from './field-def';
+export type { SchemaShape } from './field-def';
+export { BaseRuleConfig, BASE_RULE_SCHEMA } from './base-rule-config';
+export { RULE_PACK_API_VERSION, RULE_SCHEMA_API_VERSION, ConfigObject, OwnedRuleDefinition, RuleContribution, RulePackManifest, RulePackDeclaration } from './rule-pack';
+export type { ExecutionKind, ConfigValue } from './rule-pack';
+export { FILE_LIMIT_MODES, MODIFIED_CODE_MODES, ON_OFF_MODES } from './scope-modes';
+export type { FileLimitMode, ModifiedCodeMode, OnOffMode } from './scope-modes';
+export { RetiredConfigKey, SafeguardDefinition } from './rule-pack';
+export type { RuleConfigSection } from './rule-pack';

package/src/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SafeguardDefinition = exports.RetiredConfigKey = exports.ON_OFF_MODES = exports.MODIFIED_CODE_MODES = exports.FILE_LIMIT_MODES = exports.RulePackDeclaration = exports.RulePackManifest = exports.RuleContribution = exports.OwnedRuleDefinition = exports.ConfigObject = exports.RULE_SCHEMA_API_VERSION = exports.RULE_PACK_API_VERSION = exports.BASE_RULE_SCHEMA = exports.BaseRuleConfig = exports.FieldDef = void 0;
+var field_def_1 = require("./field-def");
+Object.defineProperty(exports, "FieldDef", { enumerable: true, get: function () { return field_def_1.FieldDef; } });
+var base_rule_config_1 = require("./base-rule-config");
+Object.defineProperty(exports, "BaseRuleConfig", { enumerable: true, get: function () { return base_rule_config_1.BaseRuleConfig; } });
+Object.defineProperty(exports, "BASE_RULE_SCHEMA", { enumerable: true, get: function () { return base_rule_config_1.BASE_RULE_SCHEMA; } });
+var rule_pack_1 = require("./rule-pack");
+Object.defineProperty(exports, "RULE_PACK_API_VERSION", { enumerable: true, get: function () { return rule_pack_1.RULE_PACK_API_VERSION; } });
+Object.defineProperty(exports, "RULE_SCHEMA_API_VERSION", { enumerable: true, get: function () { return rule_pack_1.RULE_SCHEMA_API_VERSION; } });
+Object.defineProperty(exports, "ConfigObject", { enumerable: true, get: function () { return rule_pack_1.ConfigObject; } });
+Object.defineProperty(exports, "OwnedRuleDefinition", { enumerable: true, get: function () { return rule_pack_1.OwnedRuleDefinition; } });
+Object.defineProperty(exports, "RuleContribution", { enumerable: true, get: function () { return rule_pack_1.RuleContribution; } });
+Object.defineProperty(exports, "RulePackManifest", { enumerable: true, get: function () { return rule_pack_1.RulePackManifest; } });
+Object.defineProperty(exports, "RulePackDeclaration", { enumerable: true, get: function () { return rule_pack_1.RulePackDeclaration; } });
+var scope_modes_1 = require("./scope-modes");
+Object.defineProperty(exports, "FILE_LIMIT_MODES", { enumerable: true, get: function () { return scope_modes_1.FILE_LIMIT_MODES; } });
+Object.defineProperty(exports, "MODIFIED_CODE_MODES", { enumerable: true, get: function () { return scope_modes_1.MODIFIED_CODE_MODES; } });
+Object.defineProperty(exports, "ON_OFF_MODES", { enumerable: true, get: function () { return scope_modes_1.ON_OFF_MODES; } });
+var rule_pack_2 = require("./rule-pack");
+Object.defineProperty(exports, "RetiredConfigKey", { enumerable: true, get: function () { return rule_pack_2.RetiredConfigKey; } });
+Object.defineProperty(exports, "SafeguardDefinition", { enumerable: true, get: function () { return rule_pack_2.SafeguardDefinition; } });
+//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/tooling/rules-sdk/src/index.ts"],"names":[],"mappings":";;;AAAA,yCAAuC;AAA9B,qGAAA,QAAQ,OAAA;AAEjB,uDAAsE;AAA7D,kHAAA,cAAc,OAAA;AAAE,oHAAA,gBAAgB,OAAA;AACzC,yCAAyK;AAAhK,kHAAA,qBAAqB,OAAA;AAAE,oHAAA,uBAAuB,OAAA;AAAE,yGAAA,YAAY,OAAA;AAAE,gHAAA,mBAAmB,OAAA;AAAE,6GAAA,gBAAgB,OAAA;AAAE,6GAAA,gBAAgB,OAAA;AAAE,gHAAA,mBAAmB,OAAA;AAEnJ,6CAAoF;AAA3E,+GAAA,gBAAgB,OAAA;AAAE,kHAAA,mBAAmB,OAAA;AAAE,2GAAA,YAAY,OAAA;AAG5D,yCAAoE;AAA3D,6GAAA,gBAAgB,OAAA;AAAE,gHAAA,mBAAmB,OAAA","sourcesContent":["export { FieldDef } from './field-def';\nexport type { SchemaShape } from './field-def';\nexport { BaseRuleConfig, BASE_RULE_SCHEMA } from './base-rule-config';\nexport { RULE_PACK_API_VERSION, RULE_SCHEMA_API_VERSION, ConfigObject, OwnedRuleDefinition, RuleContribution, RulePackManifest, RulePackDeclaration } from './rule-pack';\nexport type { ExecutionKind, ConfigValue } from './rule-pack';\nexport { FILE_LIMIT_MODES, MODIFIED_CODE_MODES, ON_OFF_MODES } from './scope-modes';\nexport type { FileLimitMode, ModifiedCodeMode, OnOffMode } from './scope-modes';\n\nexport { RetiredConfigKey, SafeguardDefinition } from './rule-pack';\nexport type { RuleConfigSection } from './rule-pack';\n"]}

package/src/rule-pack.d.ts

@@ -0,0 +1,59 @@
+import { FieldDef } from './field-def';
+/** Versioned independently from npm releases: incompatible contracts require an explicit bump. */
+export declare const RULE_PACK_API_VERSION = 2;
+export declare const RULE_SCHEMA_API_VERSION = 1;
+export type ExecutionKind = 'build' | 'source-hook' | 'workflow-guard' | 'lint';
+export type ConfigValue = string | number | boolean | null | ConfigValue[] | ConfigObject;
+export declare class ConfigObject {
+    [key: string]: ConfigValue;
+}
+/** The single owner supplies the configuration schema, regardless of implementation count. */
+export declare class OwnedRuleDefinition {
+    readonly id: string;
+    readonly schema: Readonly<Record<string, FieldDef>>;
+    readonly schemaApiVersion: number;
+    readonly optionalTuning: ConfigObject;
+    readonly recommendedSeed: ConfigObject;
+    readonly section: RuleConfigSection;
+    constructor(id: string, schema: Readonly<Record<string, FieldDef>>, schemaApiVersion: number, optionalTuning: ConfigObject, recommendedSeed: ConfigObject, section: RuleConfigSection);
+}
+/** Each pack may implement an owned rule or contribute an execution kind to another owner. */
+export declare class RuleContribution {
+    readonly ruleId: string;
+    readonly ownerPack: string;
+    readonly executionKind: ExecutionKind;
+    constructor(ruleId: string, ownerPack: string, executionKind: ExecutionKind);
+}
+export declare class RulePackManifest {
+    readonly packageName: string;
+    readonly packageVersion: string;
+    readonly apiVersion: number;
+    readonly ownedRules: readonly OwnedRuleDefinition[];
+    readonly contributions: readonly RuleContribution[];
+    readonly migrations: readonly RetiredConfigKey[];
+    readonly safeguards: readonly SafeguardDefinition[];
+    constructor(packageName: string, packageVersion: string, apiVersion: number, ownedRules: readonly OwnedRuleDefinition[], contributions: readonly RuleContribution[], migrations: readonly RetiredConfigKey[], safeguards: readonly SafeguardDefinition[]);
+}
+/** Explicit module declarations let a client add packs without a central built-in package list. */
+export declare class RulePackDeclaration {
+    readonly module: string;
+    constructor(module: string);
+}
+export type RuleConfigSection = 'rules' | 'hookGuards' | 'lint';
+/** A fixed invariant has no config switch; experimental safeguards require a separate explicit opt-in. */
+export declare class SafeguardDefinition {
+    readonly id: string;
+    readonly activation: 'fixed' | 'experimental';
+    readonly description: string;
+    constructor(id: string, activation: 'fixed' | 'experimental', description: string);
+}
+/** Owner-provided migration instructions are data; the framework rejects rather than aliases retired keys. */
+export declare class RetiredConfigKey {
+    readonly scope: string;
+    readonly key: string;
+    readonly movedTo: string;
+    readonly instruction: string;
+    readonly label: string;
+    readonly prunable: boolean;
+    constructor(scope: string, key: string, movedTo: string, instruction: string, label: string, prunable: boolean);
+}

package/src/rule-pack.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetiredConfigKey = exports.SafeguardDefinition = exports.RulePackDeclaration = exports.RulePackManifest = exports.RuleContribution = exports.OwnedRuleDefinition = exports.ConfigObject = exports.RULE_SCHEMA_API_VERSION = exports.RULE_PACK_API_VERSION = void 0;
+/** Versioned independently from npm releases: incompatible contracts require an explicit bump. */
+exports.RULE_PACK_API_VERSION = 2;
+exports.RULE_SCHEMA_API_VERSION = 1;
+class ConfigObject {
+}
+exports.ConfigObject = ConfigObject;
+/** The single owner supplies the configuration schema, regardless of implementation count. */
+class OwnedRuleDefinition {
+    id;
+    schema;
+    schemaApiVersion;
+    optionalTuning;
+    recommendedSeed;
+    section;
+    // eslint-disable-next-line @typescript-eslint/max-params
+    constructor(id, schema, schemaApiVersion, optionalTuning, recommendedSeed, section) {
+        this.id = id;
+        this.schema = schema;
+        this.schemaApiVersion = schemaApiVersion;
+        this.optionalTuning = optionalTuning;
+        this.recommendedSeed = recommendedSeed;
+        this.section = section;
+    }
+}
+exports.OwnedRuleDefinition = OwnedRuleDefinition;
+/** Each pack may implement an owned rule or contribute an execution kind to another owner. */
+class RuleContribution {
+    ruleId;
+    ownerPack;
+    executionKind;
+    constructor(ruleId, ownerPack, executionKind) {
+        this.ruleId = ruleId;
+        this.ownerPack = ownerPack;
+        this.executionKind = executionKind;
+    }
+}
+exports.RuleContribution = RuleContribution;
+class RulePackManifest {
+    packageName;
+    packageVersion;
+    apiVersion;
+    ownedRules;
+    contributions;
+    migrations;
+    safeguards;
+    // eslint-disable-next-line @typescript-eslint/max-params
+    constructor(packageName, packageVersion, apiVersion, ownedRules, contributions, migrations, safeguards) {
+        this.packageName = packageName;
+        this.packageVersion = packageVersion;
+        this.apiVersion = apiVersion;
+        this.ownedRules = ownedRules;
+        this.contributions = contributions;
+        this.migrations = migrations;
+        this.safeguards = safeguards;
+    }
+}
+exports.RulePackManifest = RulePackManifest;
+/** Explicit module declarations let a client add packs without a central built-in package list. */
+class RulePackDeclaration {
+    module;
+    constructor(module) {
+        this.module = module;
+    }
+}
+exports.RulePackDeclaration = RulePackDeclaration;
+/** A fixed invariant has no config switch; experimental safeguards require a separate explicit opt-in. */
+class SafeguardDefinition {
+    id;
+    activation;
+    description;
+    constructor(id, activation, description) {
+        this.id = id;
+        this.activation = activation;
+        this.description = description;
+    }
+}
+exports.SafeguardDefinition = SafeguardDefinition;
+/** Owner-provided migration instructions are data; the framework rejects rather than aliases retired keys. */
+class RetiredConfigKey {
+    scope;
+    key;
+    movedTo;
+    instruction;
+    label;
+    prunable;
+    // eslint-disable-next-line @typescript-eslint/max-params
+    constructor(scope, key, movedTo, instruction, label, prunable) {
+        this.scope = scope;
+        this.key = key;
+        this.movedTo = movedTo;
+        this.instruction = instruction;
+        this.label = label;
+        this.prunable = prunable;
+    }
+}
+exports.RetiredConfigKey = RetiredConfigKey;
+//# sourceMappingURL=rule-pack.js.map

package/src/rule-pack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-pack.js","sourceRoot":"","sources":["../../../../../packages/tooling/rules-sdk/src/rule-pack.ts"],"names":[],"mappings":";;;AAEA,kGAAkG;AACrF,QAAA,qBAAqB,GAAG,CAAC,CAAC;AAC1B,QAAA,uBAAuB,GAAG,CAAC,CAAC;AAGzC,MAAa,YAAY;CAExB;AAFD,oCAEC;AAED,8FAA8F;AAC9F,MAAa,mBAAmB;IAGf;IACA;IACA;IACA;IACA;IACA;IAPb,yDAAyD;IACzD,YACa,EAAU,EACV,MAA0C,EAC1C,gBAAwB,EACxB,cAA4B,EAC5B,eAA6B,EAC7B,OAA0B;QAL1B,OAAE,GAAF,EAAE,CAAQ;QACV,WAAM,GAAN,MAAM,CAAoC;QAC1C,qBAAgB,GAAhB,gBAAgB,CAAQ;QACxB,mBAAc,GAAd,cAAc,CAAc;QAC5B,oBAAe,GAAf,eAAe,CAAc;QAC7B,YAAO,GAAP,OAAO,CAAmB;IACpC,CAAC;CACP;AAVD,kDAUC;AAED,8FAA8F;AAC9F,MAAa,gBAAgB;IAEZ;IACA;IACA;IAHb,YACa,MAAc,EACd,SAAiB,EACjB,aAA4B;QAF5B,WAAM,GAAN,MAAM,CAAQ;QACd,cAAS,GAAT,SAAS,CAAQ;QACjB,kBAAa,GAAb,aAAa,CAAe;IACtC,CAAC;CACP;AAND,4CAMC;AAED,MAAa,gBAAgB;IAGZ;IACA;IACA;IACA;IACA;IACA;IACA;IARb,yDAAyD;IACzD,YACa,WAAmB,EACnB,cAAsB,EACtB,UAAkB,EAClB,UAA0C,EAC1C,aAA0C,EAC1C,UAAuC,EACvC,UAA0C;QAN1C,gBAAW,GAAX,WAAW,CAAQ;QACnB,mBAAc,GAAd,cAAc,CAAQ;QACtB,eAAU,GAAV,UAAU,CAAQ;QAClB,eAAU,GAAV,UAAU,CAAgC;QAC1C,kBAAa,GAAb,aAAa,CAA6B;QAC1C,eAAU,GAAV,UAAU,CAA6B;QACvC,eAAU,GAAV,UAAU,CAAgC;IACpD,CAAC;CACP;AAXD,4CAWC;AAED,mGAAmG;AACnG,MAAa,mBAAmB;IACP;IAArB,YAAqB,MAAc;QAAd,WAAM,GAAN,MAAM,CAAQ;IAAG,CAAC;CAC1C;AAFD,kDAEC;AAID,0GAA0G;AAC1G,MAAa,mBAAmB;IACP;IAAqB;IAA+C;IAAzF,YAAqB,EAAU,EAAW,UAAoC,EAAW,WAAmB;QAAvF,OAAE,GAAF,EAAE,CAAQ;QAAW,eAAU,GAAV,UAAU,CAA0B;QAAW,gBAAW,GAAX,WAAW,CAAQ;IAAG,CAAC;CACnH;AAFD,kDAEC;AAED,8GAA8G;AAC9G,MAAa,gBAAgB;IAGZ;IAAwB;IAAsB;IAC9C;IAA8B;IAAwB;IAHnE,yDAAyD;IACzD,YACa,KAAa,EAAW,GAAW,EAAW,OAAe,EAC7D,WAAmB,EAAW,KAAa,EAAW,QAAiB;QADvE,UAAK,GAAL,KAAK,CAAQ;QAAW,QAAG,GAAH,GAAG,CAAQ;QAAW,YAAO,GAAP,OAAO,CAAQ;QAC7D,gBAAW,GAAX,WAAW,CAAQ;QAAW,UAAK,GAAL,KAAK,CAAQ;QAAW,aAAQ,GAAR,QAAQ,CAAS;IACjF,CAAC;CACP;AAND,4CAMC","sourcesContent":["import { FieldDef } from './field-def';\n\n/** Versioned independently from npm releases: incompatible contracts require an explicit bump. */\nexport const RULE_PACK_API_VERSION = 2;\nexport const RULE_SCHEMA_API_VERSION = 1;\nexport type ExecutionKind = 'build' | 'source-hook' | 'workflow-guard' | 'lint';\nexport type ConfigValue = string | number | boolean | null | ConfigValue[] | ConfigObject;\nexport class ConfigObject {\n    [key: string]: ConfigValue;\n}\n\n/** The single owner supplies the configuration schema, regardless of implementation count. */\nexport class OwnedRuleDefinition {\n    // eslint-disable-next-line @typescript-eslint/max-params\n    constructor(\n        readonly id: string,\n        readonly schema: Readonly<Record<string, FieldDef>>,\n        readonly schemaApiVersion: number,\n        readonly optionalTuning: ConfigObject,\n        readonly recommendedSeed: ConfigObject,\n        readonly section: RuleConfigSection,\n    ) {}\n}\n\n/** Each pack may implement an owned rule or contribute an execution kind to another owner. */\nexport class RuleContribution {\n    constructor(\n        readonly ruleId: string,\n        readonly ownerPack: string,\n        readonly executionKind: ExecutionKind,\n    ) {}\n}\n\nexport class RulePackManifest {\n    // eslint-disable-next-line @typescript-eslint/max-params\n    constructor(\n        readonly packageName: string,\n        readonly packageVersion: string,\n        readonly apiVersion: number,\n        readonly ownedRules: readonly OwnedRuleDefinition[],\n        readonly contributions: readonly RuleContribution[],\n        readonly migrations: readonly RetiredConfigKey[],\n        readonly safeguards: readonly SafeguardDefinition[],\n    ) {}\n}\n\n/** Explicit module declarations let a client add packs without a central built-in package list. */\nexport class RulePackDeclaration {\n    constructor(readonly module: string) {}\n}\n\nexport type RuleConfigSection = 'rules' | 'hookGuards' | 'lint';\n\n/** A fixed invariant has no config switch; experimental safeguards require a separate explicit opt-in. */\nexport class SafeguardDefinition {\n    constructor(readonly id: string, readonly activation: 'fixed' | 'experimental', readonly description: string) {}\n}\n\n/** Owner-provided migration instructions are data; the framework rejects rather than aliases retired keys. */\nexport class RetiredConfigKey {\n    // eslint-disable-next-line @typescript-eslint/max-params\n    constructor(\n        readonly scope: string, readonly key: string, readonly movedTo: string,\n        readonly instruction: string, readonly label: string, readonly prunable: boolean,\n    ) {}\n}\n"]}

package/src/scope-modes.d.ts

@@ -0,0 +1,7 @@
+/** Shared scope vocabulary for generic custom rules and independent rule contributions. */
+export declare const FILE_LIMIT_MODES: readonly ["OFF", "NEW_AND_MODIFIED_FILES"];
+export type FileLimitMode = typeof FILE_LIMIT_MODES[number];
+export declare const MODIFIED_CODE_MODES: readonly ["OFF", "NEW_AND_MODIFIED_CODE", "NEW_AND_MODIFIED_FILES", "MODIFIED_PROJECTS", "RUN_EVERY_TIME"];
+export type ModifiedCodeMode = typeof MODIFIED_CODE_MODES[number];
+export declare const ON_OFF_MODES: readonly ["ON", "OFF"];
+export type OnOffMode = typeof ON_OFF_MODES[number];

package/src/scope-modes.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ON_OFF_MODES = exports.MODIFIED_CODE_MODES = exports.FILE_LIMIT_MODES = void 0;
+/** Shared scope vocabulary for generic custom rules and independent rule contributions. */
+exports.FILE_LIMIT_MODES = ['OFF', 'NEW_AND_MODIFIED_FILES'];
+// The two WHOLE-SCOPE modes (#1027) reuse the existing vocabulary rather than inventing names:
+//   MODIFIED_PROJECTS — every in-scope file of every project the diff touches (plus the changed files
+//                       themselves, so it is never narrower than NEW_AND_MODIFIED_FILES).
+//   RUN_EVERY_TIME    — every in-scope file in the repo, every run.
+// Both judge WHOLE files, exactly like NEW_AND_MODIFIED_FILES — only the file SET differs. They exist so
+// a rule adopted at NEW_AND_MODIFIED_CODE can be measured ("what is left?") or finished off without a
+// hack, and they are what `wp-validate-code --rule=<name> --mode=<mode> --projects=a,b` accepts.
+// Edit-time (ai-hooks) treats every non-OFF mode alike: it judges the content being written.
+exports.MODIFIED_CODE_MODES = ['OFF', 'NEW_AND_MODIFIED_CODE', 'NEW_AND_MODIFIED_FILES', 'MODIFIED_PROJECTS', 'RUN_EVERY_TIME'];
+exports.ON_OFF_MODES = ['ON', 'OFF'];
+//# sourceMappingURL=scope-modes.js.map

package/src/scope-modes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope-modes.js","sourceRoot":"","sources":["../../../../../packages/tooling/rules-sdk/src/scope-modes.ts"],"names":[],"mappings":";;;AAAA,2FAA2F;AAC9E,QAAA,gBAAgB,GAAG,CAAC,KAAK,EAAE,wBAAwB,CAAU,CAAC;AAI3E,+FAA+F;AAC/F,sGAAsG;AACtG,0FAA0F;AAC1F,oEAAoE;AACpE,yGAAyG;AACzG,sGAAsG;AACtG,iGAAiG;AACjG,6FAA6F;AAChF,QAAA,mBAAmB,GAAG,CAAC,KAAK,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,gBAAgB,CAAU,CAAC;AAIjI,QAAA,YAAY,GAAG,CAAC,IAAI,EAAE,KAAK,CAAU,CAAC","sourcesContent":["/** Shared scope vocabulary for generic custom rules and independent rule contributions. */\nexport const FILE_LIMIT_MODES = ['OFF', 'NEW_AND_MODIFIED_FILES'] as const;\n\nexport type FileLimitMode = typeof FILE_LIMIT_MODES[number];\n\n// The two WHOLE-SCOPE modes (#1027) reuse the existing vocabulary rather than inventing names:\n//   MODIFIED_PROJECTS — every in-scope file of every project the diff touches (plus the changed files\n//                       themselves, so it is never narrower than NEW_AND_MODIFIED_FILES).\n//   RUN_EVERY_TIME    — every in-scope file in the repo, every run.\n// Both judge WHOLE files, exactly like NEW_AND_MODIFIED_FILES — only the file SET differs. They exist so\n// a rule adopted at NEW_AND_MODIFIED_CODE can be measured (\"what is left?\") or finished off without a\n// hack, and they are what `wp-validate-code --rule=<name> --mode=<mode> --projects=a,b` accepts.\n// Edit-time (ai-hooks) treats every non-OFF mode alike: it judges the content being written.\nexport const MODIFIED_CODE_MODES = ['OFF', 'NEW_AND_MODIFIED_CODE', 'NEW_AND_MODIFIED_FILES', 'MODIFIED_PROJECTS', 'RUN_EVERY_TIME'] as const;\n\nexport type ModifiedCodeMode = typeof MODIFIED_CODE_MODES[number];\n\nexport const ON_OFF_MODES = ['ON', 'OFF'] as const;\n\nexport type OnOffMode = typeof ON_OFF_MODES[number];\n"]}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.