@agentxm/extension-model 0.28.4-bootstrap.0

package/dist/src/unstable/packaging/package-url.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Package URL (purl) schema for decomposing purl strings into typed parts.
+ *
+ * Follows the same String -> Parts pattern as RegistrySourcePatternSchema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+/**
+ * Structured purl components schema covering the seven spec components:
+ * type, namespace, name, version, qualifiers, and subpath. The `pkg` scheme
+ * is implicit.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const PackageUrlPartsSchema: Schema.Struct<{
+    readonly type: Schema.brand<Schema.String, "PackageType">;
+    readonly namespace: Schema.optional<Schema.String>;
+    readonly name: Schema.String;
+    readonly version: Schema.optional<Schema.String>;
+    readonly qualifiers: Schema.optional<Schema.$Record<Schema.String, Schema.NonEmptyString>>;
+    readonly subpath: Schema.optional<Schema.NonEmptyString>;
+}>;
+/**
+ * Inferred type for decomposed purl parts.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type PackageUrlParts = Schema.Schema.Type<typeof PackageUrlPartsSchema>;
+/**
+ * Format a PackageUrlParts as a human-readable display string: `name (type)`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const formatPackageDisplay: (parts: PackageUrlParts) => string;
+/**
+ * Schema that decodes purl strings into structured PackageUrlParts and
+ * encodes parts back to canonical purl strings.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const PackageUrlSchema: Schema.decodeTo<Schema.toType<Schema.Struct<{
+    readonly type: Schema.brand<Schema.String, "PackageType">;
+    readonly namespace: Schema.optional<Schema.String>;
+    readonly name: Schema.String;
+    readonly version: Schema.optional<Schema.String>;
+    readonly qualifiers: Schema.optional<Schema.$Record<Schema.String, Schema.NonEmptyString>>;
+    readonly subpath: Schema.optional<Schema.NonEmptyString>;
+}>>, Schema.String, never, never>;
+//# sourceMappingURL=package-url.d.ts.map

package/dist/src/unstable/packaging/package-url.js

@@ -0,0 +1,93 @@
+/**
+ * Package URL (purl) schema for decomposing purl strings into typed parts.
+ *
+ * Follows the same String -> Parts pattern as RegistrySourcePatternSchema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as SchemaIssue from "effect/SchemaIssue";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+import { PackageURL } from "packageurl-js";
+import { PackageTypeSchema } from "./package-type.js";
+/**
+ * Spec-conformant character set for a purl qualifier key: lowercase ASCII
+ * letters, digits, period, dash, and underscore; must start with a letter.
+ * The purl spec declares qualifier keys case-insensitive with a lowercase
+ * canonical form, so this schema accepts only the canonical form.
+ *
+ * @see https://github.com/package-url/purl-spec
+ */
+const PURL_QUALIFIER_KEY_PATTERN = /^[a-z][a-z0-9._-]*$/;
+const PurlQualifierKeySchema = Schema.String.pipe(Schema.check(Schema.isPattern(PURL_QUALIFIER_KEY_PATTERN, {
+    title: "Purl Qualifier Key",
+    description: "A purl qualifier key in canonical lowercase form. Allowed characters: ASCII letters, digits, '.', '-', '_'; must start with a letter.",
+    examples: ["repository_url", "classifier", "arch"],
+    message: "Expected a lowercase purl qualifier key like classifier or arch",
+})));
+/**
+ * Structured purl components schema covering the seven spec components:
+ * type, namespace, name, version, qualifiers, and subpath. The `pkg` scheme
+ * is implicit.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const PackageUrlPartsSchema = Schema.Struct({
+    type: PackageTypeSchema,
+    namespace: Schema.optional(Schema.String),
+    name: Schema.String,
+    version: Schema.optional(Schema.String),
+    qualifiers: Schema.optional(Schema.Record(PurlQualifierKeySchema, Schema.NonEmptyString)),
+    subpath: Schema.optional(Schema.NonEmptyString),
+}).annotate({
+    identifier: "PackageUrlParts",
+    title: "Package URL Parts",
+    description: "Decomposed purl components: type, namespace, name, version, qualifiers, and subpath.",
+});
+/**
+ * Format a PackageUrlParts as a human-readable display string: `name (type)`.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const formatPackageDisplay = (parts) => `${parts.name} (${parts.type})`;
+const decodePackageTypeSync = Schema.decodeUnknownSync(PackageTypeSchema);
+/**
+ * Loose Package URL shape pattern: `pkg:<type>/<rest>`. The scheme is
+ * case-insensitive per the purl spec, so the prefix accepts both cases.
+ * The full purl structure is validated by `PackageURL.fromString` during
+ * decoding; this pattern exists to expose a useful shape hint in JSON Schema.
+ */
+const PACKAGE_URL_PATTERN = /^[Pp][Kk][Gg]:[a-zA-Z][a-zA-Z0-9.+-]*\/.+$/;
+/**
+ * Schema that decodes purl strings into structured PackageUrlParts and
+ * encodes parts back to canonical purl strings.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const PackageUrlSchema = Schema.String.pipe(Schema.check(Schema.isPattern(PACKAGE_URL_PATTERN, {
+    title: "Package URL",
+    description: "A Package URL (purl) string identifying a package across ecosystems (e.g. pkg:npm/react@18.2.0).",
+    examples: ["pkg:npm/react@18.2.0", "pkg:pypi/requests@2.31.0", "pkg:cargo/serde@1.0"],
+    message: "Expected a Package URL like pkg:npm/react@18.2.0",
+})), Schema.decodeTo(Schema.toType(PackageUrlPartsSchema), SchemaTransformation.transformOrFail({
+    decode: (input) => {
+        try {
+            const parsed = PackageURL.fromString(input);
+            const parts = {
+                type: decodePackageTypeSync(parsed.type),
+                name: parsed.name,
+                ...(parsed.namespace != null ? { namespace: parsed.namespace } : {}),
+                ...(parsed.version != null ? { version: parsed.version } : {}),
+                ...(parsed.qualifiers != null ? { qualifiers: { ...parsed.qualifiers } } : {}),
+                ...(parsed.subpath != null ? { subpath: parsed.subpath } : {}),
+            };
+            return Effect.succeed(parts);
+        }
+        catch {
+            return Effect.fail(new SchemaIssue.Forbidden({ message: `Expected valid purl, got: ${input}` }, input));
+        }
+    },
+    encode: (value) => Effect.succeed(new PackageURL(value.type, value.namespace ?? null, value.name, value.version ?? null, value.qualifiers ?? null, value.subpath ?? null).toString()),
+})), Schema.annotate({ identifier: "PackageUrl" }));
+//# sourceMappingURL=package-url.js.map

package/dist/src/unstable/packs/manifest-schema.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Pack manifest schema definition.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+export declare const PACK_MANIFEST_FILENAME = "pack.json";
+export declare const PACK_MANIFEST_SCHEMA_URL = "https://axm.sh/schemas/pack.schema.json";
+/**
+ * Schema for pack manifest files (pack.json).
+ *
+ * Packs bundle multiple extensions (skills, MCP servers, subagents, rules,
+ * hooks, and knowledge bundles) for convenient distribution and installation. Each extension entry
+ * maps a fully qualified name to a semver version range.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const PackManifestSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"pack">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly dependencies: Schema.$Record<Schema.String, Schema.brand<Schema.NonEmptyString, "VersionRange">>;
+    readonly publish: Schema.optional<Schema.Struct<{
+        readonly visibility: Schema.optional<Schema.Literals<readonly ["public", "private"]>>;
+        readonly ignore: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    }>>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly version: Schema.brand<Schema.String, "Version">;
+    readonly description: Schema.optional<Schema.String>;
+    readonly keywords: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly repository: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly type: Schema.optional<Schema.NonEmptyString>;
+        readonly url: Schema.NonEmptyString;
+        readonly directory: Schema.optional<Schema.NonEmptyString>;
+    }>]>>;
+    readonly homepage: Schema.optional<Schema.String>;
+    readonly license: Schema.optional<Schema.String>;
+    readonly bugs: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly url: Schema.optional<Schema.NonEmptyString>;
+        readonly email: Schema.optional<Schema.NonEmptyString>;
+    }>]>>;
+    readonly authors: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly email: Schema.optional<Schema.String>;
+        readonly url: Schema.optional<Schema.String>;
+    }>>>;
+    readonly packages: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly purl: Schema.brand<Schema.NonEmptyString, "PackageIdentityPurl">;
+        readonly versionRange: Schema.optional<Schema.brand<Schema.decodeTo<Schema.toType<Schema.Struct<{
+            readonly raw: Schema.NonEmptyString;
+            readonly scheme: Schema.NonEmptyString;
+            readonly constraints: Schema.$Array<Schema.Struct<{
+                readonly comparator: Schema.Literals<readonly ["=", "!=", "<", "<=", ">", ">="]>;
+                readonly version: Schema.NonEmptyString;
+            }>>;
+        }>>, Schema.NonEmptyString, never, never>, "VersRange">>;
+    }>>>;
+    readonly $schema: Schema.optional<Schema.String>;
+}>;
+/**
+ * Inferred type for PackManifest schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type PackManifest = Schema.Schema.Type<typeof PackManifestSchema>;
+//# sourceMappingURL=manifest-schema.d.ts.map

package/dist/src/unstable/packs/manifest-schema.js

@@ -0,0 +1,34 @@
+/**
+ * Pack manifest schema definition.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+import { CommonManifestBaseFields, ExtensionNameSchema, NonPackExtensionDependencyConstraintMapSchema, } from "../extensions/common.js";
+export const PACK_MANIFEST_FILENAME = "pack.json";
+export const PACK_MANIFEST_SCHEMA_URL = "https://axm.sh/schemas/pack.schema.json";
+/**
+ * Schema for pack manifest files (pack.json).
+ *
+ * Packs bundle multiple extensions (skills, MCP servers, subagents, rules,
+ * hooks, and knowledge bundles) for convenient distribution and installation. Each extension entry
+ * maps a fully qualified name to a semver version range.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const PackManifestSchema = Schema.Struct({
+    $schema: Schema.optional(Schema.String),
+    ...CommonManifestBaseFields,
+    type: Schema.Literal("pack"),
+    name: ExtensionNameSchema.pipe(Schema.annotateKey({ messageMissingKey: "pack name is required" }), Schema.annotate({
+        description: "Short name for this pack within its owner namespace. Combined with owner, forms the FQN @owner/packs/<name>.",
+    })),
+    dependencies: NonPackExtensionDependencyConstraintMapSchema.pipe(Schema.annotateKey({ messageMissingKey: "pack dependencies are required" }), Schema.annotate({
+        description: "Install-time extension constraints. AXM resolves and installs a member version satisfying each range; `axm packs add` writes a `>=` lower bound rooted at the current resolved version, so members track their latest release without republishing the pack. Narrow a range by hand only to exclude a known-breaking member release, and note that a caret below 1.0 pins to the current patch or minor and goes stale on every later release. These constraints select installed extension versions, unlike companion-package recommendation ranges in `packages`, which are metadata only.",
+    })),
+}).annotate({
+    identifier: "PackManifest",
+    title: "Pack Manifest",
+    description: "Extension manifest file for extension packs. Bundles a curated set of skills, MCP servers, subagents, rules, hooks, and knowledge bundles into a single installable unit.",
+});
+//# sourceMappingURL=manifest-schema.js.map

package/dist/src/unstable/path-types.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Nominal path string types.
+ *
+ * Use these at module boundaries after a path has been normalized by the
+ * Effect `Path` service. Keep raw strings at external input boundaries.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Option from "effect/Option";
+import type * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+export declare const AbsolutePathSchema: Schema.brand<Schema.String, "AbsolutePath">;
+export type AbsolutePath = Schema.Schema.Type<typeof AbsolutePathSchema>;
+export declare const RelativePathSchema: Schema.brand<Schema.String, "RelativePath">;
+export type RelativePath = Schema.Schema.Type<typeof RelativePathSchema>;
+export declare const decodeAbsolutePathSync: (value: string) => AbsolutePath;
+export declare const decodeRelativePathSync: (value: string) => RelativePath;
+export declare const makeAbsolutePath: (path: Path.Path, value: string) => AbsolutePath;
+export declare const makeRelativePath: (path: Path.Path, value: string) => Option.Option<RelativePath>;
+export declare const makeWorkspaceRelativePath: (path: Path.Path, workspaceRoot: AbsolutePath | string, target: string) => Option.Option<RelativePath>;
+export declare const makeWorkspaceRelativeSourcePath: (path: Path.Path, workspaceRoot: AbsolutePath | string, target: string) => Option.Option<string>;
+//# sourceMappingURL=path-types.d.ts.map

package/dist/src/unstable/path-types.js

@@ -0,0 +1,48 @@
+/**
+ * Nominal path string types.
+ *
+ * Use these at module boundaries after a path has been normalized by the
+ * Effect `Path` service. Keep raw strings at external input boundaries.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+const looksAbsolutePath = (value) => value.startsWith("/") || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
+const looksEscapingRelativePath = (value) => value === "" || value === ".." || value.startsWith("../") || value.startsWith("..\\");
+export const AbsolutePathSchema = Schema.String.pipe(Schema.check(Schema.makeFilter((value) => looksAbsolutePath(value) ? undefined : "Expected an absolute path")), Schema.brand("AbsolutePath"));
+export const RelativePathSchema = Schema.String.pipe(Schema.check(Schema.makeFilter((value) => looksAbsolutePath(value) || looksEscapingRelativePath(value)
+    ? "Expected a relative path that stays within its root"
+    : undefined)), Schema.brand("RelativePath"));
+const decodeAbsolutePath = Schema.decodeUnknownSync(AbsolutePathSchema);
+const decodeRelativePath = Schema.decodeUnknownSync(RelativePathSchema);
+export const decodeAbsolutePathSync = (value) => decodeAbsolutePath(value);
+export const decodeRelativePathSync = (value) => decodeRelativePath(value);
+export const makeAbsolutePath = (path, value) => decodeAbsolutePath(path.resolve(value));
+export const makeRelativePath = (path, value) => {
+    if (path.isAbsolute(value))
+        return Option.none();
+    const normalized = path.normalize(value);
+    if (looksEscapingRelativePath(normalized))
+        return Option.none();
+    return Option.some(decodeRelativePath(normalized));
+};
+export const makeWorkspaceRelativePath = (path, workspaceRoot, target) => {
+    const root = path.resolve(workspaceRoot);
+    const resolvedTarget = path.isAbsolute(target)
+        ? path.resolve(target)
+        : path.resolve(root, target);
+    const relative = path.relative(root, resolvedTarget);
+    return makeRelativePath(path, relative);
+};
+export const makeWorkspaceRelativeSourcePath = (path, workspaceRoot, target) => {
+    const root = path.resolve(workspaceRoot);
+    const resolvedTarget = path.isAbsolute(target)
+        ? path.resolve(target)
+        : path.resolve(root, target);
+    const relative = path.relative(root, resolvedTarget);
+    if (path.isAbsolute(relative))
+        return Option.none();
+    return Option.some(path.normalize(relative.length === 0 ? "." : relative));
+};
+//# sourceMappingURL=path-types.js.map

package/dist/src/unstable/rules/manifest-schema.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Rule manifest schema definition.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+export declare const RULE_MANIFEST_FILENAME = "rule.json";
+export declare const RULE_EXTENSION_DIR = "rules";
+export declare const RULE_MANIFEST_SCHEMA_URL = "https://axm.sh/schemas/rule.schema.json";
+export declare const RULE_BODY_FILENAME = "RULE.md";
+/**
+ * Schema for rule manifest files (rule.json).
+ *
+ * Rules distribute behavior guidance. Placement is workspace-owned; v1 injects
+ * enabled rule bodies into the canonical instruction source file.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const RuleManifestSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"rule">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly title: Schema.optional<Schema.NonEmptyString>;
+    readonly priority: Schema.optional<Schema.Int>;
+    readonly appliesTo: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly enhances: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly requires: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly fallback: Schema.optional<Schema.Literals<readonly ["auto", "none"]>>;
+    readonly recommendedPacks: Schema.optional<Schema.$Array<Schema.brand<Schema.NonEmptyString, "PackSpec">>>;
+    readonly standalone: Schema.optional<Schema.Boolean>;
+    readonly publish: Schema.optional<Schema.Struct<{
+        readonly visibility: Schema.optional<Schema.Literals<readonly ["public", "private"]>>;
+        readonly ignore: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    }>>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly version: Schema.brand<Schema.String, "Version">;
+    readonly description: Schema.optional<Schema.String>;
+    readonly keywords: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly repository: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly type: Schema.optional<Schema.NonEmptyString>;
+        readonly url: Schema.NonEmptyString;
+        readonly directory: Schema.optional<Schema.NonEmptyString>;
+    }>]>>;
+    readonly homepage: Schema.optional<Schema.String>;
+    readonly license: Schema.optional<Schema.String>;
+    readonly bugs: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly url: Schema.optional<Schema.NonEmptyString>;
+        readonly email: Schema.optional<Schema.NonEmptyString>;
+    }>]>>;
+    readonly authors: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly email: Schema.optional<Schema.String>;
+        readonly url: Schema.optional<Schema.String>;
+    }>>>;
+    readonly packages: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly purl: Schema.brand<Schema.NonEmptyString, "PackageIdentityPurl">;
+        readonly versionRange: Schema.optional<Schema.brand<Schema.decodeTo<Schema.toType<Schema.Struct<{
+            readonly raw: Schema.NonEmptyString;
+            readonly scheme: Schema.NonEmptyString;
+            readonly constraints: Schema.$Array<Schema.Struct<{
+                readonly comparator: Schema.Literals<readonly ["=", "!=", "<", "<=", ">", ">="]>;
+                readonly version: Schema.NonEmptyString;
+            }>>;
+        }>>, Schema.NonEmptyString, never, never>, "VersRange">>;
+    }>>>;
+    readonly $schema: Schema.optional<Schema.String>;
+}>;
+/** @experimental */
+export type RuleManifest = Schema.Schema.Type<typeof RuleManifestSchema>;
+//# sourceMappingURL=manifest-schema.d.ts.map

package/dist/src/unstable/rules/manifest-schema.js

@@ -0,0 +1,43 @@
+/**
+ * Rule manifest schema definition.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+import { CommonManifestBaseFields, ExtensionNameSchema, NonPackManifestFields, } from "../extensions/common.js";
+export const RULE_MANIFEST_FILENAME = "rule.json";
+export const RULE_EXTENSION_DIR = "rules";
+export const RULE_MANIFEST_SCHEMA_URL = "https://axm.sh/schemas/rule.schema.json";
+export const RULE_BODY_FILENAME = "RULE.md";
+/**
+ * Schema for rule manifest files (rule.json).
+ *
+ * Rules distribute behavior guidance. Placement is workspace-owned; v1 injects
+ * enabled rule bodies into the canonical instruction source file.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const RuleManifestSchema = Schema.Struct({
+    $schema: Schema.optional(Schema.String),
+    ...CommonManifestBaseFields,
+    ...NonPackManifestFields,
+    type: Schema.Literal("rule"),
+    name: ExtensionNameSchema.pipe(Schema.annotateKey({ messageMissingKey: "rule name is required" }), Schema.annotate({
+        description: "Short name for this rule within its owner namespace. Combined with owner, forms the FQN @owner/rules/<name>.",
+    })),
+    title: Schema.optional(Schema.NonEmptyString.annotate({
+        description: "Optional display title for this rule.",
+    })),
+    priority: Schema.optional(Schema.Int.annotate({
+        description: "Ordering priority for instruction injection. Lower values render earlier.",
+        default: 100,
+    })),
+    appliesTo: Schema.optional(Schema.Array(Schema.NonEmptyString).annotate({
+        description: "Advisory path globs for future scoped placement. v1 inject placement does not enforce globs.",
+    })),
+}).annotate({
+    identifier: "RuleManifest",
+    title: "Rule Manifest",
+    description: "Rule manifest for behavior-guidance extensions. The rule body lives at src/RULE.md.",
+});
+//# sourceMappingURL=manifest-schema.js.map

package/dist/src/unstable/schema-issues.d.ts

@@ -0,0 +1,13 @@
+import * as SchemaIssue from "effect/SchemaIssue";
+/**
+ * Format a schema validation issue into human-readable lines with dot-notation
+ * paths.
+ *
+ * Each line has the form `"path.to.field: message"` for issues with a path, or
+ * just `"message"` for root-level issues. The result is capped at `maxIssues`
+ * lines (default 5).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const formatSchemaIssuesToLines: (issue: SchemaIssue.Issue, maxIssues?: number) => ReadonlyArray<string>;
+//# sourceMappingURL=schema-issues.d.ts.map

package/dist/src/unstable/schema-issues.js

@@ -0,0 +1,34 @@
+import * as SchemaIssue from "effect/SchemaIssue";
+const DEFAULT_MAX_ISSUES = 5;
+/**
+ * Format a schema validation issue into human-readable lines with dot-notation
+ * paths.
+ *
+ * Each line has the form `"path.to.field: message"` for issues with a path, or
+ * just `"message"` for root-level issues. The result is capped at `maxIssues`
+ * lines (default 5).
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const formatSchemaIssuesToLines = (issue, maxIssues = DEFAULT_MAX_ISSUES) => {
+    const formatter = SchemaIssue.makeFormatterStandardSchemaV1();
+    const { issues } = formatter(issue);
+    const lines = [];
+    for (const item of issues) {
+        const path = item.path;
+        if (path !== undefined && path.length > 0) {
+            const segments = path.map((segment) => {
+                if (typeof segment === "object" && segment !== null && "key" in segment) {
+                    return String(segment.key);
+                }
+                return String(segment);
+            });
+            lines.push(`${segments.join(".")}: ${item.message}`);
+        }
+        else {
+            lines.push(item.message);
+        }
+    }
+    return lines.slice(0, maxIssues);
+};
+//# sourceMappingURL=schema-issues.js.map

package/dist/src/unstable/skills/manifest-schema.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Skill manifest schema definition.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+export declare const MANIFEST_FILENAME = "skill.json";
+export declare const MANIFEST_SCHEMA_URL = "https://axm.sh/schemas/skill.schema.json";
+/**
+ * Schema for skill manifest files (skill.json).
+ *
+ * Skills extend coding agent capabilities with reusable prompts
+ * and context that can be invoked on demand.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export declare const SkillManifestSchema: Schema.Struct<{
+    readonly type: Schema.Literal<"skill">;
+    readonly name: Schema.brand<Schema.NonEmptyString, "ExtensionName">;
+    readonly enhances: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly requires: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly fallback: Schema.optional<Schema.Literals<readonly ["auto", "none"]>>;
+    readonly recommendedPacks: Schema.optional<Schema.$Array<Schema.brand<Schema.NonEmptyString, "PackSpec">>>;
+    readonly standalone: Schema.optional<Schema.Boolean>;
+    readonly publish: Schema.optional<Schema.Struct<{
+        readonly visibility: Schema.optional<Schema.Literals<readonly ["public", "private"]>>;
+        readonly ignore: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    }>>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly owner: Schema.brand<Schema.String, "Handle">;
+    readonly version: Schema.brand<Schema.String, "Version">;
+    readonly description: Schema.optional<Schema.String>;
+    readonly keywords: Schema.optional<Schema.$Array<Schema.NonEmptyString>>;
+    readonly repository: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly type: Schema.optional<Schema.NonEmptyString>;
+        readonly url: Schema.NonEmptyString;
+        readonly directory: Schema.optional<Schema.NonEmptyString>;
+    }>]>>;
+    readonly homepage: Schema.optional<Schema.String>;
+    readonly license: Schema.optional<Schema.String>;
+    readonly bugs: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Struct<{
+        readonly url: Schema.optional<Schema.NonEmptyString>;
+        readonly email: Schema.optional<Schema.NonEmptyString>;
+    }>]>>;
+    readonly authors: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly email: Schema.optional<Schema.String>;
+        readonly url: Schema.optional<Schema.String>;
+    }>>>;
+    readonly packages: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly purl: Schema.brand<Schema.NonEmptyString, "PackageIdentityPurl">;
+        readonly versionRange: Schema.optional<Schema.brand<Schema.decodeTo<Schema.toType<Schema.Struct<{
+            readonly raw: Schema.NonEmptyString;
+            readonly scheme: Schema.NonEmptyString;
+            readonly constraints: Schema.$Array<Schema.Struct<{
+                readonly comparator: Schema.Literals<readonly ["=", "!=", "<", "<=", ">", ">="]>;
+                readonly version: Schema.NonEmptyString;
+            }>>;
+        }>>, Schema.NonEmptyString, never, never>, "VersRange">>;
+    }>>>;
+    readonly $schema: Schema.optional<Schema.String>;
+}>;
+/**
+ * Inferred type for SkillManifest schema.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export type SkillManifest = Schema.Schema.Type<typeof SkillManifestSchema>;
+//# sourceMappingURL=manifest-schema.d.ts.map

package/dist/src/unstable/skills/manifest-schema.js

@@ -0,0 +1,31 @@
+/**
+ * Skill manifest schema definition.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Schema from "effect/Schema";
+import { CommonManifestBaseFields, ExtensionNameSchema, NonPackManifestFields, } from "../extensions/common.js";
+export const MANIFEST_FILENAME = "skill.json";
+export const MANIFEST_SCHEMA_URL = "https://axm.sh/schemas/skill.schema.json";
+/**
+ * Schema for skill manifest files (skill.json).
+ *
+ * Skills extend coding agent capabilities with reusable prompts
+ * and context that can be invoked on demand.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+export const SkillManifestSchema = Schema.Struct({
+    $schema: Schema.optional(Schema.String),
+    ...CommonManifestBaseFields,
+    ...NonPackManifestFields,
+    type: Schema.Literal("skill"),
+    name: ExtensionNameSchema.pipe(Schema.annotateKey({ messageMissingKey: "skill name is required" }), Schema.annotate({
+        description: "Short name for this skill within its owner namespace. Combined with owner, forms the FQN @owner/skills/<name>.",
+    })),
+}).annotate({
+    identifier: "SkillManifest",
+    title: "Skill Manifest",
+    description: "Extension manifest file for skill. Carries the registry-facing identity, version, and metadata.",
+});
+//# sourceMappingURL=manifest-schema.js.map

package/dist/src/unstable/sources/forge-grammar.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Pure per-forge source shorthand printing grammar.
+ *
+ * Each printer formats source params as the forge's canonical shorthand
+ * string. Probing and acquisition stay with the source-resolution providers;
+ * only the string grammar lives here.
+ *
+ * @experimental This API is unstable and may change without notice.
+ * @packageDocumentation
+ */
+import type { AzureReposSourceParams, BitbucketSourceParams, GitHubSourceParams, GitLabSourceParams, LocalSourceParams } from "./types.js";
+/** @experimental */
+export declare const printGitHubSource: (source: GitHubSourceParams, sourceName?: string) => string;
+/** @experimental */
+export declare const printGitLabSource: (source: GitLabSourceParams, sourceName?: string) => string;
+/** @experimental */
+export declare const printBitbucketSource: (source: BitbucketSourceParams, sourceName?: string) => string;
+/** @experimental */
+export declare const printAzureReposSource: (source: AzureReposSourceParams, sourceName?: string) => string;
+/** @experimental */
+export declare const printLocalSource: (source: LocalSourceParams) => string;
+//# sourceMappingURL=forge-grammar.d.ts.map