@agentxm/registry-protocol 0.28.4-bootstrap.0

package/dist/src/unstable/lint/catalog/skill.js

@@ -0,0 +1,64 @@
+/**
+ * `skill/*` rule catalog.
+ *
+ * Per the lint design, registry publish and `axm lint`
+ * run exactly these rules against each skill context:
+ *
+ * | ID                                     | Severity | Autofix |
+ * | -------------------------------------- | -------- | ------- |
+ * | `skill/skill-md-present`               | error    | —       |
+ * | `skill/manifest-present`               | error    | —       |
+ * | `skill/frontmatter-parseable`          | error    | —       |
+ * | `skill/frontmatter-standard-valid`      | error    | —       |
+ * | `skill/manifest-schema-valid`          | error    | —       |
+ * | `skill/manifest-keys-recognized`       | error    | —       |
+ * | `skill/standalone-declaration-valid`   | warning  | —       |
+ * | `skill/recommended-packs-valid`        | warning  | —       |
+ *
+ * The last two come from `catalog/shared/recommended-packs-rules.ts`; every
+ * non-pack catalog registers the same pair against its own manifest.
+ *
+ * All ship `kind: "advisory"`. Native-vs-non-native applicability is
+ * expressed via `check` early-return (no separate `applies` predicate); see
+ * each rule's module for the guard.
+ *
+ * Rule ids are **registered with the lint config allowlist at module-load
+ * time**, so importing this catalog extends the set of accepted
+ * `axm.json` `lint.rules` keys. Consumers that never import the
+ * catalog (the registry Worker bundle for `pack`-only routes, e.g.) don't pay
+ * the registration cost.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import { registerLintRuleIds } from "../config.js";
+import { skillMdPresentRule } from "./skill/skill-md-present.js";
+import { manifestPresentRule } from "./skill/manifest-present.js";
+import { frontmatterParseableRule } from "./skill/frontmatter-parseable.js";
+import { frontmatterStandardValidRule } from "./skill/frontmatter-standard-valid.js";
+import { manifestSchemaValidRule } from "./skill/manifest-schema-valid.js";
+import { manifestKeysRecognizedRule } from "./skill/manifest-keys-recognized.js";
+import { recommendedPacksValidRule } from "./skill/recommended-packs-valid.js";
+import { standaloneDeclarationValidRule } from "./skill/standalone-declaration-valid.js";
+/**
+ * Ordered v1 `skill/*` rule catalog. Declaration order is the evaluation
+ * order within a single `evaluateContexts` call (deterministic ordering is
+ * test-observable; see `evaluate.ts`).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const skillRules = [
+    skillMdPresentRule,
+    manifestPresentRule,
+    frontmatterParseableRule,
+    frontmatterStandardValidRule,
+    manifestSchemaValidRule,
+    manifestKeysRecognizedRule,
+    standaloneDeclarationValidRule,
+    recommendedPacksValidRule,
+];
+// Register ids into the `LintConfig.rules` allowlist. Module-load side effect:
+// a consumer that imports this catalog (or the `catalog/index` barrel) enables
+// `axm.json` `lint.rules` to reference any of the above rule ids.
+registerLintRuleIds(skillRules.map((r) => r.id));
+//# sourceMappingURL=skill.js.map

package/dist/src/unstable/lint/catalog/subagent/envelope.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `subagent/*` manifest envelope — see `../shared/envelope-rules.ts`.
+ */
+import type { SubagentRuleContext } from "../../context.js";
+export declare const subagentEnvelopeRules: import("../shared/envelope-rules.js").ManifestEnvelopeRules<SubagentRuleContext<import("../../context.js").SubagentContent>>;
+//# sourceMappingURL=envelope.d.ts.map

package/dist/src/unstable/lint/catalog/subagent/envelope.js

@@ -0,0 +1,15 @@
+/**
+ * `subagent/*` manifest envelope — see `../shared/envelope-rules.ts`.
+ */
+import { MANIFEST_FILENAME, SubagentManifestSchema, } from "@agentxm/extension-model/unstable/subagents/manifest-schema";
+import { makeManifestEnvelopeRules } from "../shared/envelope-rules.js";
+export const subagentEnvelopeRules = makeManifestEnvelopeRules({
+    namespace: "subagent",
+    manifestFile: MANIFEST_FILENAME,
+    schema: SubagentManifestSchema,
+    manifestJson: (context) => context.subject.subagentJson,
+    presentDescription: "Subagents include a root subagent.json manifest.",
+    presentMissingMessage: "subagent.json is missing. Create subagent.json with the required manifest fields (`owner`, `type`, `name`, `version`).",
+    schemaDescription: "subagent.json defines a valid subagent manifest.",
+});
+//# sourceMappingURL=envelope.js.map

package/dist/src/unstable/lint/catalog/subagent.d.ts

@@ -0,0 +1,4 @@
+import type { SubagentRuleContext } from "../context.js";
+import type { LintRule } from "../rule.js";
+export declare const subagentRules: ReadonlyArray<LintRule<SubagentRuleContext>>;
+//# sourceMappingURL=subagent.d.ts.map

package/dist/src/unstable/lint/catalog/subagent.js

@@ -0,0 +1,6 @@
+import { registerLintRuleIds } from "../config.js";
+import { orderedEnvelopeRules } from "./shared/envelope-rules.js";
+import { subagentEnvelopeRules } from "./subagent/envelope.js";
+export const subagentRules = orderedEnvelopeRules(subagentEnvelopeRules);
+registerLintRuleIds(subagentRules.map((r) => r.id));
+//# sourceMappingURL=subagent.js.map

package/dist/src/unstable/lint/compose-path.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `composePath` — render a display path from a rule context's `displayRoot`
+ * and a finding's accessor-relative `location.file`.
+ *
+ * Rules emit accessor-relative `location.file` values only; messages carry no
+ * paths or coordinates. The format-time composition here lets the same rule
+ * render different paths for publish (`displayRoot: ""`), registry-installed
+ * skills, external skills, and workspace-scope findings.
+ *
+ * Relative rendered paths are posix and prefixed with `./` so logs are
+ * unambiguous about relative-ness. Absolute finding paths are preserved for
+ * files outside the workspace root. `location.line` / `location.column`
+ * append as `:line:column` when present.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { FindingLocation } from "./rule.js";
+/**
+ * Compose the rendered path for a finding.
+ *
+ * @param displayRoot - Context-supplied posix-relative root (or `""`).
+ * @param location    - Accessor-relative or absolute file + optional coordinates.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const composePath: (displayRoot: string, location: FindingLocation | undefined) => string;
+//# sourceMappingURL=compose-path.d.ts.map

package/dist/src/unstable/lint/compose-path.js

@@ -0,0 +1,64 @@
+/**
+ * `composePath` — render a display path from a rule context's `displayRoot`
+ * and a finding's accessor-relative `location.file`.
+ *
+ * Rules emit accessor-relative `location.file` values only; messages carry no
+ * paths or coordinates. The format-time composition here lets the same rule
+ * render different paths for publish (`displayRoot: ""`), registry-installed
+ * skills, external skills, and workspace-scope findings.
+ *
+ * Relative rendered paths are posix and prefixed with `./` so logs are
+ * unambiguous about relative-ness. Absolute finding paths are preserved for
+ * files outside the workspace root. `location.line` / `location.column`
+ * append as `:line:column` when present.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+// -----------------------------------------------------------------------------
+// composePath
+// -----------------------------------------------------------------------------
+/**
+ * Compose the rendered path for a finding.
+ *
+ * @param displayRoot - Context-supplied posix-relative root (or `""`).
+ * @param location    - Accessor-relative or absolute file + optional coordinates.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const composePath = (displayRoot, location) => {
+    const locationFile = location?.file ?? "";
+    const base = isAbsolutePath(locationFile) ? locationFile : joinPosix(displayRoot, locationFile);
+    const withPrefix = base === "" ? "." : isAbsolutePath(base) || base.startsWith("./") ? base : `./${base}`;
+    if (location === undefined) {
+        return withPrefix;
+    }
+    return appendCoordinates(withPrefix, location);
+};
+const isAbsolutePath = (value) => value.startsWith("/") || value.startsWith("\\\\") || /^[A-Za-z]:[\\/]/.test(value);
+const joinPosix = (left, right) => {
+    const l = stripTrailingSlash(left);
+    const r = stripLeadingSlash(right);
+    if (l === "" && r === "") {
+        return "";
+    }
+    if (l === "") {
+        return r;
+    }
+    if (r === "") {
+        return l;
+    }
+    return `${l}/${r}`;
+};
+const stripTrailingSlash = (s) => (s.endsWith("/") ? s.slice(0, -1) : s);
+const stripLeadingSlash = (s) => (s.startsWith("/") ? s.slice(1) : s);
+const appendCoordinates = (path, location) => {
+    if (location.line === undefined) {
+        return path;
+    }
+    if (location.column === undefined) {
+        return `${path}:${location.line}`;
+    }
+    return `${path}:${location.line}:${location.column}`;
+};
+//# sourceMappingURL=compose-path.js.map

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

@@ -0,0 +1,103 @@
+/**
+ * `LintConfig` — workspace-settings-level lint configuration.
+ *
+ * Workspace settings carry a `lint` section whose `rules` map binds rule ids
+ * to `"off" | "info" | "warn" | "error"`. The registry publish
+ * gate ignores workspace overrides; this config affects `axm lint` only.
+ *
+ * Keys are **exact** rule ids (`<namespace>/<name>`). No glob, wildcard, or
+ * regex syntax is accepted in v1. The accepted-key set is built at schema
+ * construction time from rule ids registered via `registerLintRuleIds` — the
+ * three v1 catalogs (`skill/*`, `pack/*`, `workspace/*`) each register their
+ * ids so adding a catalog in a later phase extends the set by construction.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Schema from "effect/Schema";
+/**
+ * Accepted values for a `lint.rules` entry.
+ *
+ * Note: `"warn"` is the config surface for `Severity` `"warning"`; mirror's
+ * ESLint convention. The evaluator treats `"warn"` as equivalent to `warning`
+ * severity; `"off"` suppresses emission.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const LintRuleSeveritySchema: Schema.Literals<readonly ["off", "info", "warn", "error"]>;
+/**
+ * Effective severity of a `lint.rules` entry.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type LintRuleSeverity = Schema.Schema.Type<typeof LintRuleSeveritySchema>;
+/**
+ * Register one or more rule ids into the config allowlist.
+ *
+ * Each v1 rule catalog calls this once at module-load to extend the set of
+ * accepted `lint.rules` keys. Calls are additive and idempotent — registering
+ * an id twice is a no-op. A rule id that isn't registered will cause
+ * `SettingsSchema` decode to fail at the `lint.rules` key, surfacing the
+ * unknown id in the error path.
+ *
+ * Consumers (Phases 3a/3b/3c) should register from the catalog module by
+ * iterating the catalog's own rule array: no copy-paste of rule ids into this
+ * file.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const registerLintRuleIds: (ids: Iterable<string>) => void;
+/**
+ * Read-only view of the currently-registered rule ids.
+ *
+ * Mainly useful for tests and snapshots; production callers should not depend
+ * on ordering.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const registeredLintRuleIds: () => ReadonlySet<string>;
+/**
+ * Record of `<namespace>/<name>` ids to severity overrides.
+ *
+ * Unknown / wildcard / regex keys are rejected at decode by the filter — the
+ * filter walks the decoded record's keys and checks every key against the
+ * registered rule-id set. Wildcard patterns like `"skill/*"` fail the filter
+ * because they are not registered ids.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const LintRulesMapSchema: Schema.$Record<Schema.String, Schema.Literals<readonly ["off", "info", "warn", "error"]>>;
+/**
+ * Inferred type for `LintRulesMap`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type LintRulesMap = Schema.Schema.Type<typeof LintRulesMapSchema>;
+/**
+ * `lint` section of `axm.json`.
+ *
+ * Today only `rules` is defined; future fields (per-rule options, reporter
+ * selection) extend this struct. The schema rejects excess top-level keys so
+ * typos surface at decode.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const LintConfigSchema: Schema.Struct<{
+    readonly rules: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Literals<readonly ["off", "info", "warn", "error"]>>>;
+}>;
+/**
+ * Inferred type for `LintConfig`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type LintConfig = Schema.Schema.Type<typeof LintConfigSchema>;
+/**
+ * The platform-canonical `LintConfig` — empty rules, no overrides.
+ *
+ * Registry publish uses this config; it carries no overrides so every rule
+ * fires at its catalog severity.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const platformCanonicalLintConfig: LintConfig;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1,140 @@
+/**
+ * `LintConfig` — workspace-settings-level lint configuration.
+ *
+ * Workspace settings carry a `lint` section whose `rules` map binds rule ids
+ * to `"off" | "info" | "warn" | "error"`. The registry publish
+ * gate ignores workspace overrides; this config affects `axm lint` only.
+ *
+ * Keys are **exact** rule ids (`<namespace>/<name>`). No glob, wildcard, or
+ * regex syntax is accepted in v1. The accepted-key set is built at schema
+ * construction time from rule ids registered via `registerLintRuleIds` — the
+ * three v1 catalogs (`skill/*`, `pack/*`, `workspace/*`) each register their
+ * ids so adding a catalog in a later phase extends the set by construction.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import * as Schema from "effect/Schema";
+// -----------------------------------------------------------------------------
+// Config value schema
+// -----------------------------------------------------------------------------
+/**
+ * Accepted values for a `lint.rules` entry.
+ *
+ * Note: `"warn"` is the config surface for `Severity` `"warning"`; mirror's
+ * ESLint convention. The evaluator treats `"warn"` as equivalent to `warning`
+ * severity; `"off"` suppresses emission.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const LintRuleSeveritySchema = Schema.Literals(["off", "info", "warn", "error"]).annotate({
+    identifier: "LintRuleSeverity",
+    title: "Lint Rule Severity",
+    description: "Severity override for a lint rule: 'off' silences it, 'info'/'warn'/'error' raise or lower severity.",
+});
+// -----------------------------------------------------------------------------
+// Registered rule-id allowlist
+// -----------------------------------------------------------------------------
+/**
+ * Internal mutable registry of accepted rule ids, populated at module-load
+ * time by each rule catalog's side-effecting `registerLintRuleIds` call.
+ *
+ * The registry is module-local so callers in other packages can't extend it
+ * without going through `registerLintRuleIds`; the v1 catalogs register from
+ * `./catalog/skill.ts`, `./catalog/pack.ts`, and `./catalog/workspace.ts` in
+ * Phases 3a/3b/3c.
+ */
+const registeredRuleIds = new Set();
+/**
+ * Register one or more rule ids into the config allowlist.
+ *
+ * Each v1 rule catalog calls this once at module-load to extend the set of
+ * accepted `lint.rules` keys. Calls are additive and idempotent — registering
+ * an id twice is a no-op. A rule id that isn't registered will cause
+ * `SettingsSchema` decode to fail at the `lint.rules` key, surfacing the
+ * unknown id in the error path.
+ *
+ * Consumers (Phases 3a/3b/3c) should register from the catalog module by
+ * iterating the catalog's own rule array: no copy-paste of rule ids into this
+ * file.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const registerLintRuleIds = (ids) => {
+    for (const id of ids) {
+        registeredRuleIds.add(id);
+    }
+};
+/**
+ * Read-only view of the currently-registered rule ids.
+ *
+ * Mainly useful for tests and snapshots; production callers should not depend
+ * on ordering.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const registeredLintRuleIds = () => registeredRuleIds;
+// -----------------------------------------------------------------------------
+// Rules map schema
+// -----------------------------------------------------------------------------
+const ruleIdKeyFilter = Schema.makeFilter((input) => {
+    const invalid = [];
+    for (const key of Object.keys(input)) {
+        if (!registeredRuleIds.has(key)) {
+            invalid.push(key);
+        }
+    }
+    if (invalid.length === 0) {
+        return undefined;
+    }
+    return `Unknown lint rule IDs in lint.rules: ${invalid.join(", ")}. Keys must be exact <namespace>/<name> IDs; wildcards and globs are not supported.`;
+});
+/**
+ * Record of `<namespace>/<name>` ids to severity overrides.
+ *
+ * Unknown / wildcard / regex keys are rejected at decode by the filter — the
+ * filter walks the decoded record's keys and checks every key against the
+ * registered rule-id set. Wildcard patterns like `"skill/*"` fail the filter
+ * because they are not registered ids.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const LintRulesMapSchema = Schema.Record(Schema.String, LintRuleSeveritySchema)
+    .annotate({
+    identifier: "LintRulesMap",
+    title: "Lint Rules Map",
+    description: "Map of exact <namespace>/<name> rule ids to severity overrides for `axm lint`.",
+})
+    .check(ruleIdKeyFilter);
+// -----------------------------------------------------------------------------
+// LintConfig schema
+// -----------------------------------------------------------------------------
+/**
+ * `lint` section of `axm.json`.
+ *
+ * Today only `rules` is defined; future fields (per-rule options, reporter
+ * selection) extend this struct. The schema rejects excess top-level keys so
+ * typos surface at decode.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const LintConfigSchema = Schema.Struct({
+    rules: Schema.optionalKey(LintRulesMapSchema.annotate({
+        description: "Exact lint rule ids mapped to severity overrides.",
+        examples: [{ "workspace/settings-schema-valid": "error" }],
+    })),
+}).annotate({
+    identifier: "LintConfig",
+    title: "Lint Config",
+    description: "Lint configuration under `lint` in workspace settings.",
+});
+/**
+ * The platform-canonical `LintConfig` — empty rules, no overrides.
+ *
+ * Registry publish uses this config; it carries no overrides so every rule
+ * fires at its catalog severity.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const platformCanonicalLintConfig = { rules: {} };
+//# sourceMappingURL=config.js.map