@agentyx/core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andersseen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,77 @@
+# @agentyx/core
+
+Domain foundations for [Agentyx](https://github.com/Andersseen/agentyx): the `.agentyx.json` configuration
+model, stack definitions, built-in stack/skill/MCP registries, optimization profiles, and
+resolution.
+
+This package has no dependency on Commander or any terminal UI — CLI concerns live in
+[`@agentyx/cli`](https://github.com/Andersseen/agentyx/tree/main/packages/cli).
+
+```ts
+import {
+  builtInSkillRegistry,
+  builtInStacks,
+  loadAgentyxConfig,
+  resolveAgentyxConfig,
+  resolveStackMcpServerReferences,
+  resolveStacks,
+  resolveStackSkills,
+} from "@agentyx/core";
+
+resolveStacks(["angular"]);
+// ["core", "typescript", "angular"]
+
+resolveStackSkills(["angular"]);
+// ["planning", "systematic-debugging", "verification", "typescript-modern", "angular-modern"]
+
+resolveStackMcpServerReferences(["angular"]);
+// [{ name: "context7", level: "recommended" }]
+
+resolveAgentyxConfig(await loadAgentyxConfig(process.cwd()));
+// { requestedStacks, resolvedStacks, skills, declaredMcpServers, mcpServers, profile, targets }
+```
+
+## Skills
+
+A skill is provider-independent instruction text: `{ name, description, content }` and nothing else.
+The built-in skills ship as `SKILL.md` files under `skills/`, with YAML frontmatter for the metadata
+and the Markdown body as the content, and are published alongside `dist/`.
+
+Resolution works on identifiers, and `SkillRegistry.get(name)` is what reads a body:
+
+```ts
+builtInSkillRegistry.names; // identifiers, no file is read
+builtInSkillRegistry.has("planning"); // no file is read
+builtInSkillRegistry.get("planning"); // reads, validates and caches SKILL.md
+```
+
+`createSkillRegistry(sources)` builds an independent registry from `{ name, load }` sources — the
+seam an external registry would use later. `parseSkillMarkdown(markdown, origin)` parses one
+`SKILL.md`, and `formatSkillMarkdown(skill)` renders one deterministically. That serializer is the
+canonical form every provider installs, which is why it lives here: an adapter decides where a skill
+goes, never what it says.
+
+MCP resolution keeps both declared and effective capabilities visible. Profiles are provider-neutral:
+`lean` enables essential MCP only, `balanced` enables essential and recommended MCP, and
+`autonomous` enables essential, recommended and optional MCP. Skill identifiers are not filtered by
+profile.
+
+The JSON Schema for `.agentyx.json` ships with the package:
+
+```json
+{
+  "$schema": "./node_modules/@agentyx/core/schema/agentyx.schema.json"
+}
+```
+
+Resolution failures throw domain errors — `UnknownStackError`, `CircularStackDependencyError`,
+`UnknownSkillError`, `DuplicateSkillError`, `InvalidSkillError`, `AgentyxConfigNotFoundError`,
+`AgentyxConfigParseError`, `AgentyxConfigValidationError` — all extending `AgentyxError` with a stable
+`code`.
+
+Installing skills and effective MCP capabilities into an agent is
+[`@agentyx/adapters`](https://github.com/Andersseen/agentyx/tree/main/packages/adapters); core knows
+nothing about providers. See the [main README](https://github.com/Andersseen/agentyx#readme) for the
+full picture.
+
+MIT © Andersseen

package/dist/index.d.mts

@@ -0,0 +1,541 @@
+import { ZodError, z } from "zod";
+//#region src/errors.d.ts
+/**
+ * Base class for every failure Agentyx raises deliberately.
+ *
+ * Consumers can catch `AgentyxError` to separate expected domain failures from
+ * unexpected runtime errors, and branch on the stable `code` when they need to
+ * handle a specific failure.
+ */
+declare class AgentyxError extends Error {
+  readonly code: string;
+  constructor(code: string, message: string, options?: ErrorOptions);
+}
+//#endregion
+//#region src/config/errors.d.ts
+/** A single configuration problem, addressed by its location in the document. */
+interface AgentyxConfigIssue {
+  /** Dotted path to the offending value, or `(root)` for the document itself. */
+  readonly path: string;
+  readonly message: string;
+}
+/** Raised when the supplied directory has no `.agentyx.json`. */
+declare class AgentyxConfigNotFoundError extends AgentyxError {
+  readonly filePath: string;
+  constructor(filePath: string, options?: ErrorOptions);
+}
+/** Raised when `.agentyx.json` is not valid JSON. */
+declare class AgentyxConfigParseError extends AgentyxError {
+  readonly filePath: string;
+  constructor(filePath: string, reason: string, options?: ErrorOptions);
+}
+/** Raised when the document parses as JSON but violates the Agentyx schema. */
+declare class AgentyxConfigValidationError extends AgentyxError {
+  readonly issues: readonly AgentyxConfigIssue[];
+  /** The file the configuration came from, when it was read from disk. */
+  readonly filePath: string | undefined;
+  constructor(error: ZodError, filePath?: string);
+}
+//#endregion
+//#region src/config/json-schema.d.ts
+/** Canonical identifier of the published `.agentyx.json` schema. */
+declare const AGENTYX_CONFIG_SCHEMA_ID = "https://agentyx.dev/schema/agentyx.schema.json";
+/**
+ * Derives the JSON Schema for `.agentyx.json` from the Zod model, which stays the
+ * single source of truth. The committed `schema/agentyx.schema.json` is generated
+ * from this function and verified by tests.
+ *
+ * The `input` view is used so that fields with defaults stay optional, which is
+ * what an author writing the file cares about.
+ */
+declare function buildAgentyxConfigJsonSchema(): Record<string, unknown>;
+//#endregion
+//#region src/config/schema.d.ts
+/** How much autonomy the generated environment should grant an agent. */
+declare const AGENTYX_PROFILES: readonly ["lean", "balanced", "autonomous"];
+declare const agentyxProfileSchema: z.ZodEnum<{
+  lean: "lean";
+  balanced: "balanced";
+  autonomous: "autonomous";
+}>;
+type AgentyxProfile = z.infer<typeof agentyxProfileSchema>;
+/** Applied when a configuration omits `profile`. */
+declare const DEFAULT_AGENTYX_PROFILE: AgentyxProfile;
+/** The `.agentyx.json` project configuration. */
+declare const agentyxConfigSchema: z.ZodObject<{
+  $schema: z.ZodOptional<z.ZodString>;
+  extends: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  profile: z.ZodDefault<z.ZodEnum<{
+    lean: "lean";
+    balanced: "balanced";
+    autonomous: "autonomous";
+  }>>;
+  targets: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+/** A validated configuration, with defaults applied. */
+type AgentyxConfig = z.infer<typeof agentyxConfigSchema>;
+/** The shape accepted in a `.agentyx.json` file. */
+type AgentyxConfigInput = z.input<typeof agentyxConfigSchema>;
+//#endregion
+//#region src/config/loader.d.ts
+declare const AGENTYX_CONFIG_FILENAME = ".agentyx.json";
+/** The absolute path `.agentyx.json` is read from for a given project. */
+declare function agentyxConfigPath(projectPath?: string): string;
+/**
+ * Validates an already-parsed configuration document.
+ *
+ * @throws {AgentyxConfigValidationError} when the document violates the schema.
+ */
+declare function parseAgentyxConfig(value: unknown, filePath?: string): AgentyxConfig;
+/**
+ * Reads and validates `.agentyx.json` from `projectPath`.
+ *
+ * Parent directories are not searched, and invalid configurations are never
+ * silently repaired.
+ *
+ * @throws {AgentyxConfigNotFoundError} when the file does not exist.
+ * @throws {AgentyxConfigParseError} when the file is not valid JSON.
+ * @throws {AgentyxConfigValidationError} when the document violates the schema.
+ */
+declare function loadAgentyxConfig(projectPath?: string): Promise<AgentyxConfig>;
+//#endregion
+//#region src/mcp/schema.d.ts
+declare const MCP_CAPABILITY_LEVELS: readonly ["essential", "recommended", "optional"];
+declare const mcpCapabilityLevelSchema: z.ZodEnum<{
+  optional: "optional";
+  essential: "essential";
+  recommended: "recommended";
+}>;
+declare const MCP_CONTEXT_COSTS: readonly ["low", "medium", "high"];
+declare const mcpContextCostSchema: z.ZodEnum<{
+  low: "low";
+  medium: "medium";
+  high: "high";
+}>;
+declare const mcpEnvReferenceSchema: z.ZodObject<{
+  fromEnv: z.ZodString;
+}, z.core.$strict>;
+declare const mcpServerReferenceSchema: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+  name: z.ZodString;
+  level: z.ZodDefault<z.ZodEnum<{
+    optional: "optional";
+    essential: "essential";
+    recommended: "recommended";
+  }>>;
+}, z.core.$strict>]>, z.ZodTransform<{
+  name: string;
+  level: "optional" | "essential" | "recommended";
+}, string | {
+  name: string;
+  level: "optional" | "essential" | "recommended";
+}>>, z.ZodObject<{
+  name: z.ZodString;
+  level: z.ZodEnum<{
+    optional: "optional";
+    essential: "essential";
+    recommended: "recommended";
+  }>;
+}, z.core.$strict>>;
+declare const mcpServerDefinitionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodString;
+  contextCost: z.ZodOptional<z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+  }>>;
+  transport: z.ZodLiteral<"stdio">;
+  command: z.ZodString;
+  args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+    fromEnv: z.ZodString;
+  }, z.core.$strict>>>;
+}, z.core.$strict>, z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodString;
+  contextCost: z.ZodOptional<z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+  }>>;
+  transport: z.ZodLiteral<"http">;
+  url: z.ZodURL;
+  headers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+    fromEnv: z.ZodString;
+  }, z.core.$strict>>>;
+}, z.core.$strict>], "transport">;
+type McpEnvReference = z.infer<typeof mcpEnvReferenceSchema>;
+type McpCapabilityLevel = z.infer<typeof mcpCapabilityLevelSchema>;
+type McpContextCost = z.infer<typeof mcpContextCostSchema>;
+type McpServerDefinition = z.infer<typeof mcpServerDefinitionSchema>;
+type McpServerDefinitionInput = z.input<typeof mcpServerDefinitionSchema>;
+type McpServerReference = z.infer<typeof mcpServerReferenceSchema>;
+type McpServerReferenceInput = z.input<typeof mcpServerReferenceSchema>;
+//#endregion
+//#region src/mcp/registry.d.ts
+interface McpServerSource {
+  readonly name: string;
+  load(): McpServerDefinitionInput;
+}
+interface McpServerMetadata {
+  readonly name: string;
+  readonly description: string;
+  readonly transport: McpServerDefinition["transport"];
+  readonly contextCost?: McpServerDefinition["contextCost"];
+}
+interface McpServerRegistry {
+  readonly names: readonly string[];
+  has(name: string): boolean;
+  listMetadata(): readonly McpServerMetadata[];
+  get(name: string): McpServerDefinition;
+}
+declare function createMcpServerRegistry(sources: Iterable<McpServerSource>): McpServerRegistry;
+//#endregion
+//#region src/skill/schema.d.ts
+/**
+ * A Skill is reusable instruction text for a coding agent. It is deliberately
+ * provider-independent: nothing here says how or where a provider installs it.
+ */
+declare const skillDefinitionSchema: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodString;
+  content: z.ZodString;
+}, z.core.$strict>;
+/** A validated skill definition. */
+type SkillDefinition = z.infer<typeof skillDefinitionSchema>;
+/** The shape accepted when authoring a skill definition. */
+type SkillDefinitionInput = z.input<typeof skillDefinitionSchema>;
+//#endregion
+//#region src/skill/registry.d.ts
+/**
+ * Where a single skill comes from. The name is known up front so that listing
+ * and existence checks stay cheap, and `load` is only called when something
+ * actually needs the instructions — a design that keeps `resolve` working on
+ * identifiers alone.
+ *
+ * This is also the seam an external or remote registry would plug into later.
+ */
+interface SkillSource {
+  readonly name: string;
+  /** Produces the definition. Called at most once per registry. */
+  load(): SkillDefinitionInput;
+}
+/** A name lookup over skills, independent of where the definitions live. */
+interface SkillRegistry {
+  /** Registered names in registration order. Never reads a skill body. */
+  readonly names: readonly string[];
+  has(name: string): boolean;
+  /**
+   * Loads, validates and caches a skill.
+   *
+   * @throws {UnknownSkillError} when the name is not registered.
+   * @throws {InvalidSkillError} when the source yields an invalid definition.
+   */
+  get(name: string): SkillDefinition;
+}
+/**
+ * Indexes skill sources by name.
+ *
+ * Names and duplicates are validated here; the definitions themselves are
+ * validated the first time each skill is loaded.
+ *
+ * @throws {DuplicateSkillError} when two sources share a name.
+ * @throws {InvalidSkillError} when a source name is not a valid skill name.
+ */
+declare function createSkillRegistry(sources: Iterable<SkillSource>): SkillRegistry;
+//#endregion
+//#region src/stack/schema.d.ts
+/**
+ * A stack describes a development environment that can build on other stacks
+ * and contribute provider-agnostic capabilities to them.
+ */
+declare const stackDefinitionSchema: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  extends: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  mcpServers: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    level: z.ZodDefault<z.ZodEnum<{
+      optional: "optional";
+      essential: "essential";
+      recommended: "recommended";
+    }>>;
+  }, z.core.$strict>]>, z.ZodTransform<{
+    name: string;
+    level: "optional" | "essential" | "recommended";
+  }, string | {
+    name: string;
+    level: "optional" | "essential" | "recommended";
+  }>>, z.ZodObject<{
+    name: z.ZodString;
+    level: z.ZodEnum<{
+      optional: "optional";
+      essential: "essential";
+      recommended: "recommended";
+    }>;
+  }, z.core.$strict>>>>;
+}, z.core.$strict>;
+/** A validated stack definition, with defaults always present. */
+type StackDefinition = z.infer<typeof stackDefinitionSchema>;
+/** The shape accepted when authoring a stack definition. */
+type StackDefinitionInput = z.input<typeof stackDefinitionSchema>;
+//#endregion
+//#region src/stack/registry.d.ts
+/**
+ * A registry is a name lookup over stack definitions. Keeping it a plain map
+ * means the resolver stays independent of where definitions come from, so
+ * external registries can be added later without touching resolution.
+ */
+type StackRegistry = ReadonlyMap<string, StackDefinition>;
+/** Validates definitions and indexes them by name. */
+declare function createStackRegistry(definitions: Iterable<StackDefinitionInput>): StackRegistry;
+/**
+ * The stacks Agentyx ships with, expressed as data. Relationships live here, not
+ * in the resolver.
+ */
+declare const builtInStacks: readonly StackDefinitionInput[];
+/** The registry used by default when no explicit registry is supplied. */
+declare const builtInStackRegistry: StackRegistry;
+//#endregion
+//#region src/config/resolver.d.ts
+/** A project configuration with its stack inheritance expanded. */
+interface ResolvedAgentyxConfig {
+  /** The stacks the project asked for, in configuration order. */
+  readonly requestedStacks: readonly string[];
+  /** The full inheritance chain, dependency-first and de-duplicated. */
+  readonly resolvedStacks: readonly string[];
+  /**
+   * Skill identifiers contributed by the resolved stacks, in resolution order.
+   * Identifiers only — reading the instructions is a separate, explicit step.
+   */
+  readonly skills: readonly string[];
+  readonly declaredMcpServers: readonly McpServerReference[];
+  readonly mcpServers: readonly string[];
+  readonly profile: AgentyxProfile;
+  readonly targets: readonly string[];
+}
+/**
+ * Combines a validated project configuration with stack and skill resolution.
+ * The input is never mutated.
+ *
+ * @throws {UnknownStackError} when a configured stack is missing.
+ * @throws {CircularStackDependencyError} when inheritance forms a cycle.
+ * @throws {UnknownSkillError} when a stack references an unknown skill.
+ */
+declare function resolveAgentyxConfig(config: AgentyxConfig, registry?: StackRegistry, skillRegistry?: SkillRegistry, mcpRegistry?: McpServerRegistry): ResolvedAgentyxConfig;
+//#endregion
+//#region src/mcp/built-in.d.ts
+declare const builtInMcpServerRegistry: McpServerRegistry;
+declare const builtInMcpServerNames: readonly string[];
+//#endregion
+//#region src/mcp/errors.d.ts
+declare class UnknownMcpServerError extends AgentyxError {
+  readonly serverName: string;
+  readonly requiredBy: string | undefined;
+  readonly knownServers: readonly string[];
+  constructor(serverName: string, requiredBy: string | undefined, knownServers: readonly string[]);
+}
+declare class DuplicateMcpServerError extends AgentyxError {
+  readonly serverName: string;
+  constructor(serverName: string);
+}
+declare class InvalidMcpServerError extends AgentyxError {
+  readonly origin: string;
+  readonly reason: string;
+  constructor(origin: string, reason: string | ZodError, options?: ErrorOptions);
+}
+//#endregion
+//#region src/mcp/resolver.d.ts
+declare function collectStackMcpServerReferences(resolvedStacks: readonly string[], stackRegistry: StackRegistry, mcpRegistry: McpServerRegistry): McpServerReference[];
+declare function filterEffectiveMcpServers(servers: readonly McpServerReference[], profile: AgentyxProfile): string[];
+declare function collectStackMcpServers(resolvedStacks: readonly string[], stackRegistry: StackRegistry, mcpRegistry: McpServerRegistry, profile?: AgentyxProfile): string[];
+declare function resolveStackMcpServerReferences(requestedStacks: readonly string[], stackRegistry?: StackRegistry, mcpRegistry?: McpServerRegistry): McpServerReference[];
+declare function resolveStackMcpServers(requestedStacks: readonly string[], stackRegistry?: StackRegistry, mcpRegistry?: McpServerRegistry, profile?: AgentyxProfile): string[];
+//#endregion
+//#region src/meta.d.ts
+declare const agentyxCoreName = "agentyx-core";
+declare function getCoreStatus(): string;
+//#endregion
+//#region src/optimization/profile.d.ts
+interface OptimizationProfileDefinition {
+  readonly name: AgentyxProfile;
+  readonly goal: string;
+  readonly mcpLevels: readonly McpCapabilityLevel[];
+  readonly notes: readonly string[];
+}
+declare const optimizationProfiles: readonly OptimizationProfileDefinition[];
+declare const optimizationProfileNames: readonly AgentyxProfile[];
+declare function getOptimizationProfile(name: AgentyxProfile): OptimizationProfileDefinition;
+declare function isMcpLevelEnabled(profile: AgentyxProfile, level: McpCapabilityLevel): boolean;
+//#endregion
+//#region src/project/detector.d.ts
+declare const PACKAGE_MANAGERS: readonly ["pnpm", "npm", "yarn", "bun"];
+type PackageManagerName = (typeof PACKAGE_MANAGERS)[number];
+interface PackageManagerDetection {
+  readonly name: PackageManagerName | undefined;
+  readonly source: "lockfile" | "package-json" | undefined;
+  readonly lockfiles: readonly string[];
+  readonly ambiguous: boolean;
+}
+interface ProjectPackageJsonDetection {
+  readonly present: boolean;
+  readonly valid: boolean;
+  readonly path: string;
+  readonly name: string | undefined;
+  readonly packageManager: string | undefined;
+  readonly error: string | undefined;
+}
+interface ProjectDetection {
+  readonly projectDir: string;
+  readonly packageJson: ProjectPackageJsonDetection;
+  readonly packageManager: PackageManagerDetection;
+  readonly detectedStacks: readonly string[];
+  readonly recommendedStack: string | undefined;
+}
+declare function detectProject(projectDir: string): Promise<ProjectDetection>;
+declare function buildAgentyxConfig(input: {
+  readonly stack: string;
+  readonly profile: AgentyxProfile;
+  readonly targets: readonly string[];
+}): AgentyxConfigInput;
+declare function formatAgentyxConfig(config: AgentyxConfigInput): string;
+//#endregion
+//#region src/skill/built-in.d.ts
+/**
+ * The skills Agentyx ships with. The names are the directory names under
+ * `packages/core/skills`, and knowing them without touching the filesystem is
+ * what lets stack resolution validate references without reading any body.
+ */
+declare const builtInSkillNames: readonly ["planning", "systematic-debugging", "verification", "typescript-modern", "angular-modern"];
+/** The registry used by default when no explicit registry is supplied. */
+declare const builtInSkillRegistry: SkillRegistry;
+//#endregion
+//#region src/skill/errors.d.ts
+/**
+ * Raised when a stack references a skill the registry does not know.
+ *
+ * The offending name is exposed as `skillName`; `stack` stays the JS stack
+ * trace inherited from `Error`.
+ */
+declare class UnknownSkillError extends AgentyxError {
+  readonly skillName: string;
+  /** The stack that declared the skill, when the failure came from resolution. */
+  readonly requiredBy: string | undefined;
+  readonly knownSkills: readonly string[];
+  constructor(skillName: string, requiredBy: string | undefined, knownSkills: readonly string[]);
+}
+/** Raised when a registry is built from sources that reuse a skill name. */
+declare class DuplicateSkillError extends AgentyxError {
+  readonly skillName: string;
+  constructor(skillName: string);
+}
+/**
+ * Raised when a skill exists but cannot be turned into a valid definition —
+ * malformed `SKILL.md` frontmatter, a missing field, an unreadable file.
+ *
+ * Built-in skills ship with Agentyx, so this is a programmer error rather than
+ * something a user can fix in their project.
+ */
+declare class InvalidSkillError extends AgentyxError {
+  /** Where the skill came from: a file path, or a label for an in-memory source. */
+  readonly origin: string;
+  readonly reason: string;
+  constructor(origin: string, reason: string | ZodError, options?: ErrorOptions);
+}
+//#endregion
+//#region src/skill/markdown.d.ts
+/**
+ * A `SKILL.md` file is a frontmatter block followed by the Markdown body:
+ *
+ * ```md
+ * ---
+ * name: planning
+ * description: Plan non-trivial work before editing.
+ * ---
+ *
+ * Instructions...
+ * ```
+ *
+ * The frontmatter is a deliberately small YAML subset — a flat block of
+ * `key: value` pairs, values optionally quoted — so that core keeps depending
+ * on Zod alone. Anything richer is rejected rather than guessed at.
+ *
+ * The body is preserved as written apart from trimming the blank lines around
+ * it, and `origin` is only used to make errors readable.
+ *
+ * @throws {InvalidSkillError} when the frontmatter or the resulting skill is invalid.
+ */
+declare function parseSkillMarkdown(markdown: string, origin: string): SkillDefinition;
+/**
+ * Renders a skill as canonical `SKILL.md` text — the inverse of
+ * `parseSkillMarkdown`, and the single representation every consumer installs.
+ *
+ * Keeping this in core is what stops a provider from owning a copy of a skill
+ * body: an adapter decides *where* a skill goes, never what it says.
+ *
+ * The output is deterministic. Frontmatter is always `name` then `description`,
+ * the body is the trimmed content, and the file ends with exactly one newline,
+ * so re-rendering an unchanged skill produces a byte-identical file and an
+ * installer can compare content instead of guessing.
+ *
+ * @throws {InvalidSkillError} when the definition is invalid, or when the
+ * description cannot be represented in the flat frontmatter subset the parser
+ * accepts.
+ */
+declare function formatSkillMarkdown(skill: SkillDefinitionInput): string;
+//#endregion
+//#region src/skill/resolver.d.ts
+/**
+ * Expands the requested stacks and returns the skills they contribute.
+ *
+ * The result follows the resolved stack order, then each stack's declaration
+ * order, and is de-duplicated by first occurrence. Skills do not extend other
+ * skills, so there is nothing further to expand.
+ *
+ * @throws {UnknownStackError} when a requested or inherited stack is missing.
+ * @throws {CircularStackDependencyError} when stack inheritance forms a cycle.
+ * @throws {UnknownSkillError} when a stack references a skill the registry lacks.
+ */
+declare function resolveStackSkills(requestedStacks: readonly string[], stackRegistry?: StackRegistry, skillRegistry?: SkillRegistry): string[];
+//#endregion
+//#region src/stack/errors.d.ts
+/**
+ * Raised when a requested or inherited stack is not present in the registry.
+ *
+ * The offending name is exposed as `stackName`; `stack` stays the JS stack
+ * trace inherited from `Error`.
+ */
+declare class UnknownStackError extends AgentyxError {
+  readonly stackName: string;
+  readonly requiredBy: string | undefined;
+  readonly knownStacks: readonly string[];
+  constructor(stackName: string, requiredBy: string | undefined, knownStacks: readonly string[]);
+}
+/** Raised when stack inheritance forms a cycle. */
+declare class CircularStackDependencyError extends AgentyxError {
+  /** The cycle path, starting and ending with the same stack. */
+  readonly cycle: readonly string[];
+  constructor(cycle: readonly string[]);
+}
+/** Raised when a registry is built from definitions that reuse a stack name. */
+declare class DuplicateStackError extends AgentyxError {
+  readonly stackName: string;
+  constructor(stackName: string);
+}
+//#endregion
+//#region src/stack/resolver.d.ts
+/**
+ * Expands the requested stacks into the full inheritance chain.
+ *
+ * The result is dependency-first, de-duplicated and deterministic: stacks are
+ * visited in the order they are requested, and each stack's parents are visited
+ * in declaration order before the stack itself.
+ *
+ * @throws {UnknownStackError} when a requested or inherited stack is missing.
+ * @throws {CircularStackDependencyError} when inheritance forms a cycle.
+ */
+declare function resolveStacks(requestedStacks: readonly string[], registry?: StackRegistry): string[];
+//#endregion
+export { AGENTYX_CONFIG_FILENAME, AGENTYX_CONFIG_SCHEMA_ID, AGENTYX_PROFILES, type AgentyxConfig, type AgentyxConfigInput, type AgentyxConfigIssue, AgentyxConfigNotFoundError, AgentyxConfigParseError, AgentyxConfigValidationError, AgentyxError, type AgentyxProfile, CircularStackDependencyError, DEFAULT_AGENTYX_PROFILE, DuplicateMcpServerError, DuplicateSkillError, DuplicateStackError, InvalidMcpServerError, InvalidSkillError, MCP_CAPABILITY_LEVELS, MCP_CONTEXT_COSTS, type McpCapabilityLevel, type McpContextCost, type McpEnvReference, type McpServerDefinition, type McpServerDefinitionInput, type McpServerMetadata, type McpServerReference, type McpServerReferenceInput, type McpServerRegistry, type McpServerSource, type OptimizationProfileDefinition, PACKAGE_MANAGERS, type PackageManagerDetection, type PackageManagerName, type ProjectDetection, type ProjectPackageJsonDetection, type ResolvedAgentyxConfig, type SkillDefinition, type SkillDefinitionInput, type SkillRegistry, type SkillSource, type StackDefinition, type StackDefinitionInput, type StackRegistry, UnknownMcpServerError, UnknownSkillError, UnknownStackError, agentyxConfigPath, agentyxConfigSchema, agentyxCoreName, agentyxProfileSchema, buildAgentyxConfig, buildAgentyxConfigJsonSchema, builtInMcpServerNames, builtInMcpServerRegistry, builtInSkillNames, builtInSkillRegistry, builtInStackRegistry, builtInStacks, collectStackMcpServerReferences, collectStackMcpServers, createMcpServerRegistry, createSkillRegistry, createStackRegistry, detectProject, filterEffectiveMcpServers, formatAgentyxConfig, formatSkillMarkdown, getCoreStatus, getOptimizationProfile, isMcpLevelEnabled, loadAgentyxConfig, mcpCapabilityLevelSchema, mcpContextCostSchema, mcpEnvReferenceSchema, mcpServerDefinitionSchema, mcpServerReferenceSchema, optimizationProfileNames, optimizationProfiles, parseAgentyxConfig, parseSkillMarkdown, resolveAgentyxConfig, resolveStackMcpServerReferences, resolveStackMcpServers, resolveStackSkills, resolveStacks, skillDefinitionSchema, stackDefinitionSchema };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/errors.ts","../src/config/errors.ts","../src/config/json-schema.ts","../src/config/schema.ts","../src/config/loader.ts","../src/mcp/schema.ts","../src/mcp/registry.ts","../src/skill/schema.ts","../src/skill/registry.ts","../src/stack/schema.ts","../src/stack/registry.ts","../src/config/resolver.ts","../src/mcp/built-in.ts","../src/mcp/errors.ts","../src/mcp/resolver.ts","../src/meta.ts","../src/optimization/profile.ts","../src/project/detector.ts","../src/skill/built-in.ts","../src/skill/errors.ts","../src/skill/markdown.ts","../src/skill/resolver.ts","../src/stack/errors.ts","../src/stack/resolver.ts"],"mappings":"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"}