@agentxm/client-core 0.1.6 → 0.3.1

package/dist/src/unstable/lint/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Lint engine — shared-kernel primitives for the AgentXM lint engine.
+ *
+ * Library-style discriminated unions and a pure evaluator. Rules are plain
+ * values generic over a caller-built context; the registry publish gate and
+ * `axm lint` each build contexts from their own runtimes and call
+ * `evaluateContexts` / `collectFixOperations`.
+ *
+ * Phase 2 ships the primitives, evaluator, rule-context types, narrow accessor
+ * surfaces, `composePath` renderer, schema-delegation helper
+ * (`issuesToFindings`), and the `LintConfig` section of `SettingsSchema`.
+ *
+ * Phases 3a, 3b, 3c land the concrete catalogs (`skillRules`, `packRules`,
+ * `workspaceRules`) and register their rule ids via `registerLintRuleIds`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export type { AdvisoryFinding, AdvisoryRule, AutofixableFinding, AutofixingRule, FindingBase, FindingLocation, LintFinding, LintRule, RuleBase, Severity, } from "./rule.js";
+export { collectFixOperations, evaluateContexts, type Evaluated } from "./evaluate.js";
+export type { AgentDetection, FileAccessError, LockfileDocument, LockfileReadError, PackContent, PackFileAccessor, PackRuleContext, SettingsDocument, SettingsReadError, SkillContent, SkillFileAccessor, SkillRuleContext, WorkspaceLintAccessor, WorkspaceRuleContext, WorkspaceSubject, } from "./context.js";
+export { composePath } from "./compose-path.js";
+export { issuesToFindings } from "./issues-to-findings.js";
+export type { LintConfig, LintRuleSeverity, LintRulesMap } from "./config.js";
+export { LintConfigSchema, LintRuleSeveritySchema, LintRulesMapSchema, platformCanonicalLintConfig, registerLintRuleIds, registeredLintRuleIds, } from "./config.js";
+export { collectAutofixableEntries, collectRenderedFindings, countFindings, detectPublishGateDrift, evaluateAllCatalogs, renderFindingsText, resolveLintExitCategory, summarizeEvaluations, toLintJsonDocument, type FindingCounts, type FixSummary, type GroupEvaluations, type LintExitCategory, type LintJsonDocument, type LintJsonFinding, type LintSummary, type RenderFindingsArgs, type RenderedFinding, } from "./cli.js";
+export { allCatalogRuleIds, buildExternalInstalledSkillInfo, buildInstalledPackInfo, buildNativeInstalledSkillInfo, buildPackRuleContexts, buildSkillRuleContexts, buildWorkspaceRuleContext, externalSkillDisplayRoot, isPerExtensionOperationName, makePlatformPackFileAccessor, makePlatformSkillFileAccessor, makePlatformWorkspaceLintAccessor, makeVftPackFileAccessor, makeVftSkillFileAccessor, packRules, PER_EXTENSION_OPERATION_NAMES, registryNativeSkillDisplayRoot, registryPackDisplayRoot, skillRules, workspaceRules, type BuildInstalledPackInfoArgs, type BuildInstalledSkillInfoExternalArgs, type BuildInstalledSkillInfoNativeArgs, type BuildWorkspaceRuleContextArgs, type InstalledPackInfo, type InstalledSkillInfo, type PackAccessorPlatform, type PackIndexView, type PackVFTNode, type PerExtensionOperationName, type PlatformWorkspaceLintAccessorArgs, type SkillAccessorPlatform, type SkillIndexView, type VFTNode, type WorkspaceAccessorPlatform, type WorkspaceIndex, type WorkspaceIndexView, } from "./catalog/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/unstable/lint/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/unstable/lint/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,YAAY,EACV,eAAe,EACf,YAAY,EACZ,kBAAkB,EAClB,cAAc,EACd,WAAW,EACX,eAAe,EACf,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,QAAQ,GACT,MAAM,WAAW,CAAC;AAGnB,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAGvF,YAAY,EACV,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,WAAW,EACX,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,EAChB,qBAAqB,EACrB,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAG3D,YAAY,EAAE,UAAU,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC9E,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,kBAAkB,EAClB,2BAA2B,EAC3B,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,aAAa,CAAC;AAKrB,OAAO,EACL,yBAAyB,EACzB,uBAAuB,EACvB,aAAa,EACb,sBAAsB,EACtB,mBAAmB,EACnB,kBAAkB,EAClB,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,EAClB,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,eAAe,GACrB,MAAM,UAAU,CAAC;AAMlB,OAAO,EACL,iBAAiB,EACjB,+BAA+B,EAC/B,sBAAsB,EACtB,6BAA6B,EAC7B,qBAAqB,EACrB,sBAAsB,EACtB,yBAAyB,EACzB,wBAAwB,EACxB,2BAA2B,EAC3B,4BAA4B,EAC5B,6BAA6B,EAC7B,iCAAiC,EACjC,uBAAuB,EACvB,wBAAwB,EACxB,SAAS,EACT,6BAA6B,EAC7B,8BAA8B,EAC9B,uBAAuB,EACvB,UAAU,EACV,cAAc,EACd,KAAK,0BAA0B,EAC/B,KAAK,mCAAmC,EACxC,KAAK,iCAAiC,EACtC,KAAK,6BAA6B,EAClC,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,yBAAyB,EAC9B,KAAK,iCAAiC,EACtC,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACnB,KAAK,OAAO,EACZ,KAAK,yBAAyB,EAC9B,KAAK,cAAc,EACnB,KAAK,kBAAkB,GACxB,MAAM,oBAAoB,CAAC"}

package/dist/src/unstable/lint/index.js

@@ -0,0 +1,35 @@
+/**
+ * Lint engine — shared-kernel primitives for the AgentXM lint engine.
+ *
+ * Library-style discriminated unions and a pure evaluator. Rules are plain
+ * values generic over a caller-built context; the registry publish gate and
+ * `axm lint` each build contexts from their own runtimes and call
+ * `evaluateContexts` / `collectFixOperations`.
+ *
+ * Phase 2 ships the primitives, evaluator, rule-context types, narrow accessor
+ * surfaces, `composePath` renderer, schema-delegation helper
+ * (`issuesToFindings`), and the `LintConfig` section of `SettingsSchema`.
+ *
+ * Phases 3a, 3b, 3c land the concrete catalogs (`skillRules`, `packRules`,
+ * `workspaceRules`) and register their rule ids via `registerLintRuleIds`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+// Evaluator and fix-operation collection
+export { collectFixOperations, evaluateContexts } from "./evaluate.js";
+// Path rendering
+export { composePath } from "./compose-path.js";
+// Schema-delegation helper
+export { issuesToFindings } from "./issues-to-findings.js";
+export { LintConfigSchema, LintRuleSeveritySchema, LintRulesMapSchema, platformCanonicalLintConfig, registerLintRuleIds, registeredLintRuleIds, } from "./config.js";
+// Lint runner (Phase 5) — reusable primitives the `axm lint` CLI composes
+// over. Keeps the CLI command file a thin surface over flag parsing and
+// rendering per task 5.11.
+export { collectAutofixableEntries, collectRenderedFindings, countFindings, detectPublishGateDrift, evaluateAllCatalogs, renderFindingsText, resolveLintExitCategory, summarizeEvaluations, toLintJsonDocument, } from "./cli.js";
+// Rule catalogs (Phase 3a lands `skillRules`; Phase 3b lands `packRules`;
+// Phase 3c lands `workspaceRules`). Importing this index triggers each
+// catalog's module-load `registerLintRuleIds(...)` call so
+// `.axm/settings.json` `lint.rules` keys can reference any exported rule id.
+export { allCatalogRuleIds, buildExternalInstalledSkillInfo, buildInstalledPackInfo, buildNativeInstalledSkillInfo, buildPackRuleContexts, buildSkillRuleContexts, buildWorkspaceRuleContext, externalSkillDisplayRoot, isPerExtensionOperationName, makePlatformPackFileAccessor, makePlatformSkillFileAccessor, makePlatformWorkspaceLintAccessor, makeVftPackFileAccessor, makeVftSkillFileAccessor, packRules, PER_EXTENSION_OPERATION_NAMES, registryNativeSkillDisplayRoot, registryPackDisplayRoot, skillRules, workspaceRules, } from "./catalog/index.js";
+//# sourceMappingURL=index.js.map

package/dist/src/unstable/lint/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/unstable/lint/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAgBH,yCAAyC;AACzC,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAkB,MAAM,eAAe,CAAC;AAqBvF,iBAAiB;AACjB,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,2BAA2B;AAC3B,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAI3D,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,kBAAkB,EAClB,2BAA2B,EAC3B,mBAAmB,EACnB,qBAAqB,GACtB,MAAM,aAAa,CAAC;AAErB,0EAA0E;AAC1E,wEAAwE;AACxE,2BAA2B;AAC3B,OAAO,EACL,yBAAyB,EACzB,uBAAuB,EACvB,aAAa,EACb,sBAAsB,EACtB,mBAAmB,EACnB,kBAAkB,EAClB,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,GAUnB,MAAM,UAAU,CAAC;AAElB,0EAA0E;AAC1E,uEAAuE;AACvE,2DAA2D;AAC3D,6EAA6E;AAC7E,OAAO,EACL,iBAAiB,EACjB,+BAA+B,EAC/B,sBAAsB,EACtB,6BAA6B,EAC7B,qBAAqB,EACrB,sBAAsB,EACtB,yBAAyB,EACzB,wBAAwB,EACxB,2BAA2B,EAC3B,4BAA4B,EAC5B,6BAA6B,EAC7B,iCAAiC,EACjC,uBAAuB,EACvB,wBAAwB,EACxB,SAAS,EACT,6BAA6B,EAC7B,8BAA8B,EAC9B,uBAAuB,EACvB,UAAU,EACV,cAAc,GAkBf,MAAM,oBAAoB,CAAC"}

package/dist/src/unstable/lint/issues-to-findings.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `issuesToFindings` — shared schema-delegation helper.
+ *
+ * `-schema-valid` rules delegate their `check` to Effect Schema via
+ * `Schema.decodeUnknownResult(schema, { onExcessProperty: "ignore" })` (or the
+ * Effect/Exit equivalents) and map the resulting `Issue` tree 1:1 to
+ * `AdvisoryFinding`s through this helper. Rules never re-implement schema
+ * checks inline; the paired `-keys-recognized` rule owns unknown-key hygiene
+ * at warning severity.
+ *
+ * The helper walks the recursive `SchemaIssue.Issue` tree, accumulating a
+ * path at each `Pointer` node and emitting one finding per leaf issue.
+ * Composite nodes recurse into their children. Each finding's `message` comes
+ * from the default `toString()` representation of the leaf issue, which is
+ * the Effect-formatted diagnostic. `location.file` is the caller-supplied
+ * file (the manifest file); v1 does not parse byte positions out of `Issue`
+ * values.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { Issue } from "effect/SchemaIssue";
+import type { AdvisoryFinding, Severity } from "./rule.js";
+/**
+ * Walk an `Issue` tree and produce one finding per leaf issue.
+ *
+ * @param ruleId    - `<namespace>/<name>` id of the calling rule.
+ * @param severity  - Severity to stamp on each emitted finding.
+ * @param file      - Accessor-relative file path to stamp on `location.file`.
+ * @param issue     - Root `Issue` produced by `Schema.decodeUnknown*`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const issuesToFindings: (ruleId: string, severity: Severity, file: string, issue: Issue) => ReadonlyArray<AdvisoryFinding>;
+//# sourceMappingURL=issues-to-findings.d.ts.map

package/dist/src/unstable/lint/issues-to-findings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issues-to-findings.d.ts","sourceRoot":"","sources":["../../../../src/unstable/lint/issues-to-findings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAM3D;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,MAAM,EACd,UAAU,QAAQ,EAClB,MAAM,MAAM,EACZ,OAAO,KAAK,KACX,aAAa,CAAC,eAAe,CAM/B,CAAC"}

package/dist/src/unstable/lint/issues-to-findings.js

@@ -0,0 +1,97 @@
+/**
+ * `issuesToFindings` — shared schema-delegation helper.
+ *
+ * `-schema-valid` rules delegate their `check` to Effect Schema via
+ * `Schema.decodeUnknownResult(schema, { onExcessProperty: "ignore" })` (or the
+ * Effect/Exit equivalents) and map the resulting `Issue` tree 1:1 to
+ * `AdvisoryFinding`s through this helper. Rules never re-implement schema
+ * checks inline; the paired `-keys-recognized` rule owns unknown-key hygiene
+ * at warning severity.
+ *
+ * The helper walks the recursive `SchemaIssue.Issue` tree, accumulating a
+ * path at each `Pointer` node and emitting one finding per leaf issue.
+ * Composite nodes recurse into their children. Each finding's `message` comes
+ * from the default `toString()` representation of the leaf issue, which is
+ * the Effect-formatted diagnostic. `location.file` is the caller-supplied
+ * file (the manifest file); v1 does not parse byte positions out of `Issue`
+ * values.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+// -----------------------------------------------------------------------------
+// Public helper
+// -----------------------------------------------------------------------------
+/**
+ * Walk an `Issue` tree and produce one finding per leaf issue.
+ *
+ * @param ruleId    - `<namespace>/<name>` id of the calling rule.
+ * @param severity  - Severity to stamp on each emitted finding.
+ * @param file      - Accessor-relative file path to stamp on `location.file`.
+ * @param issue     - Root `Issue` produced by `Schema.decodeUnknown*`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const issuesToFindings = (ruleId, severity, file, issue) => {
+    const findings = [];
+    walkIssue(issue, [], (leaf, path) => {
+        findings.push(toFinding(ruleId, severity, file, leaf, path));
+    });
+    return findings;
+};
+const walkIssue = (issue, path, visit) => {
+    switch (issue._tag) {
+        case "Pointer": {
+            walkIssue(issue.issue, [...path, ...issue.path], visit);
+            return;
+        }
+        case "Composite":
+        case "AnyOf": {
+            if (issue.issues.length === 0) {
+                // No union member matched / no nested issues — treat as a leaf so
+                // the caller sees at least one finding for the covering diagnostic.
+                visit(issue, path);
+                return;
+            }
+            for (const child of issue.issues) {
+                walkIssue(child, path, visit);
+            }
+            return;
+        }
+        case "Filter":
+        case "Encoding": {
+            walkIssue(issue.issue, path, visit);
+            return;
+        }
+        case "InvalidType":
+        case "InvalidValue":
+        case "MissingKey":
+        case "UnexpectedKey":
+        case "Forbidden":
+        case "OneOf": {
+            visit(issue, path);
+            return;
+        }
+    }
+};
+const toFinding = (ruleId, severity, file, issue, path) => {
+    const pathStr = formatPath(path);
+    const message = pathStr === "" ? String(issue) : `${pathStr}: ${String(issue)}`;
+    return {
+        kind: "advisory",
+        ruleId,
+        severity,
+        message,
+        suggestions: [],
+        location: { file },
+    };
+};
+const formatPath = (path) => path
+    .map((segment) => {
+    if (typeof segment === "number") {
+        return `[${String(segment)}]`;
+    }
+    return String(segment);
+})
+    .join(".");
+//# sourceMappingURL=issues-to-findings.js.map

package/dist/src/unstable/lint/issues-to-findings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"issues-to-findings.js","sourceRoot":"","sources":["../../../../src/unstable/lint/issues-to-findings.ts"],"names":[],"mappings":"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"}

package/dist/src/unstable/lint/rule.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Lint rule and finding primitives.
+ *
+ * Library-style discriminated unions for the lint engine. Rules are plain
+ * values generic over a caller-built `RuleContext` — no Layer wiring, no
+ * ambient service bag. Findings are produced by `rule.check`; an
+ * `AutofixingRule` also carries a `fix` method that returns per-extension
+ * `Operation` values for `axm lint --fix`. Rules that don't apply early-return
+ * `[]` from `check`; there is no separate `applies` predicate.
+ *
+ * Rule `fix` methods compose only from the pre-sync per-extension vocabulary
+ * (`install-{type}`, `uninstall-{type}`, `enable-{type}`, `disable-{type}`) so
+ * lint-fix rides the same plan pipeline as `axm install`. See
+ * `../plan/plan.ts` for the `Operation` primitive.
+ *
+ * Rule ids follow `<namespace>/<subject>-<predicate>` with lowercase letters,
+ * digits, and hyphens; ids leak into settings files, CI logs, and agent
+ * transcripts, so they are public API stable under a deprecation-alias policy
+ * per the `lint-engine` design doc.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type * as Effect from "effect/Effect";
+import type { Operation } from "../plan/plan.js";
+/**
+ * Platform-canonical finding severity.
+ *
+ * Workspace `lint.rules` overrides can raise or lower the severity at
+ * evaluation time; the catalog pins the platform default.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type Severity = "error" | "warning" | "info";
+/**
+ * Accessor-relative location of a finding.
+ *
+ * `file` is posix and relative to the rule context's accessor root (skill or
+ * pack manifest directory for per-extension rules, workspace root for workspace
+ * rules). Rules MUST NOT embed absolute paths, `displayRoot`-qualified paths,
+ * or source coordinates in `message`; the display path is composed from
+ * `context.displayRoot` and `location.file` at format time via `composePath`.
+ *
+ * `file: ""` targets the context root itself (e.g., a missing `SKILL.md` on a
+ * skill context).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface FindingLocation {
+    readonly file: string;
+    readonly line?: number;
+    readonly column?: number;
+    readonly byteOffset?: number;
+    readonly byteLength?: number;
+}
+/**
+ * Fields common to all lint findings.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface FindingBase {
+    readonly ruleId: string;
+    readonly severity: Severity;
+    readonly message: string;
+    readonly location?: FindingLocation;
+}
+/**
+ * Finding produced by an `AutofixingRule` that `axm lint --fix` will remediate
+ * mechanically.
+ *
+ * `suggestions` is a one-element tuple naming what `--fix` will do; the
+ * tuple arity is enforced at the type level so consumers never have to guard
+ * against an empty suggestions array for autofixable findings.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface AutofixableFinding extends FindingBase {
+    readonly kind: "autofixable";
+    readonly suggestions: readonly [string];
+}
+/**
+ * Finding produced by an `AdvisoryRule` (or by an `AutofixingRule`'s advisory
+ * arm when the invariant admits no mechanical resolution).
+ *
+ * `suggestions` may be empty or carry multiple strings; the user picks one.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface AdvisoryFinding extends FindingBase {
+    readonly kind: "advisory";
+    readonly suggestions: ReadonlyArray<string>;
+}
+/**
+ * Discriminated union of lint findings on `kind`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type LintFinding = AutofixableFinding | AdvisoryFinding;
+/**
+ * Fields common to all lint rules.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface RuleBase {
+    readonly id: string;
+    readonly description: string;
+    readonly severity: Severity;
+}
+/**
+ * Rule that only surfaces findings; never autofixes.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface AdvisoryRule<C> extends RuleBase {
+    readonly kind: "advisory";
+    readonly check: (context: C) => Effect.Effect<ReadonlyArray<AdvisoryFinding>>;
+}
+/**
+ * Rule that can emit `AutofixableFinding`s and remediate them via
+ * pre-sync per-extension `Operation`s.
+ *
+ * `check` may return `AdvisoryFinding`s alongside (for sub-cascades that have
+ * no single mechanical resolution); `fix` is only invoked for the autofixable
+ * arm.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export interface AutofixingRule<C> extends RuleBase {
+    readonly kind: "autofixing";
+    readonly check: (context: C) => Effect.Effect<ReadonlyArray<LintFinding>>;
+    readonly fix: (context: C, finding: AutofixableFinding) => Effect.Effect<ReadonlyArray<Operation<string, unknown>>>;
+}
+/**
+ * Discriminated union of lint rules over a caller-built rule-context type `C`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type LintRule<C> = AdvisoryRule<C> | AutofixingRule<C>;
+//# sourceMappingURL=rule.d.ts.map

package/dist/src/unstable/lint/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/unstable/lint/rule.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAMjD;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;AAMpD;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAMD;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,eAAe,CAAC;CACrC;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,kBAAmB,SAAQ,WAAW;IACrD,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;CACzC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,eAAgB,SAAQ,WAAW;IAClD,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CAC7C;AAED;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,kBAAkB,GAAG,eAAe,CAAC;AAM/D;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;CAC7B;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC,CAAE,SAAQ,QAAQ;IAC/C,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC,CAAC;CAC/E;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC,CAAE,SAAQ,QAAQ;IACjD,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC,CAAC;IAC1E,QAAQ,CAAC,GAAG,EAAE,CACZ,OAAO,EAAE,CAAC,EACV,OAAO,EAAE,kBAAkB,KACxB,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;CAC/D;AAED;;;;GAIG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC"}

package/dist/src/unstable/lint/rule.js

@@ -0,0 +1,25 @@
+/**
+ * Lint rule and finding primitives.
+ *
+ * Library-style discriminated unions for the lint engine. Rules are plain
+ * values generic over a caller-built `RuleContext` — no Layer wiring, no
+ * ambient service bag. Findings are produced by `rule.check`; an
+ * `AutofixingRule` also carries a `fix` method that returns per-extension
+ * `Operation` values for `axm lint --fix`. Rules that don't apply early-return
+ * `[]` from `check`; there is no separate `applies` predicate.
+ *
+ * Rule `fix` methods compose only from the pre-sync per-extension vocabulary
+ * (`install-{type}`, `uninstall-{type}`, `enable-{type}`, `disable-{type}`) so
+ * lint-fix rides the same plan pipeline as `axm install`. See
+ * `../plan/plan.ts` for the `Operation` primitive.
+ *
+ * Rule ids follow `<namespace>/<subject>-<predicate>` with lowercase letters,
+ * digits, and hyphens; ids leak into settings files, CI logs, and agent
+ * transcripts, so they are public API stable under a deprecation-alias policy
+ * per the `lint-engine` design doc.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+export {};
+//# sourceMappingURL=rule.js.map

package/dist/src/unstable/lint/rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/unstable/lint/rule.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG"}