@perstack/core 0.0.54 → 0.0.55

package/dist/src/schemas/expert.d.ts

@@ -1,309 +0,0 @@
-import { z } from "zod";
-import type { AnthropicProviderSkill, ProviderToolOptions } from "./provider-tools.js";
-import type { RuntimeVersion } from "./runtime-version.js";
-import type { Skill } from "./skill.js";
-/**
- * An Expert definition - an AI agent with specific skills and instructions.
- * Experts can delegate to other Experts and use MCP tools.
- */
-export interface Expert {
-    /** Unique key identifying this Expert (e.g., "my-expert" or "my-expert@1.0.0") */
-    key: string;
-    /** Display name for the Expert */
-    name: string;
-    /** Semantic version string */
-    version: string;
-    /** Human-readable description of what this Expert does */
-    description?: string;
-    /** System instruction defining the Expert's behavior */
-    instruction: string;
-    /** Map of skill name to skill configuration */
-    skills: Record<string, Skill>;
-    /** List of Expert keys this Expert can delegate to */
-    delegates: string[];
-    /** Tags for categorization and discovery */
-    tags: string[];
-    /** Minimum runtime version required to run this Expert */
-    minRuntimeVersion: RuntimeVersion;
-    /** Provider-specific tool names to enable (e.g., "webSearch", "codeExecution") */
-    providerTools?: string[];
-    /** Anthropic Agent Skills configuration */
-    providerSkills?: AnthropicProviderSkill[];
-    /** Provider tool options (e.g., webSearch maxUses, allowedDomains) */
-    providerToolOptions?: ProviderToolOptions;
-}
-/**
- * Base object schema for Expert. Use this for `.omit()` / `.pick()` operations.
- * For parsing with delegation validation, use `expertSchema` instead.
- */
-export declare const expertBaseSchema: z.ZodObject<{
-    key: z.ZodString;
-    name: z.ZodString;
-    version: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    instruction: z.ZodString;
-    skills: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"mcpStdioSkill">;
-        description: z.ZodOptional<z.ZodString>;
-        args: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-        rule: z.ZodOptional<z.ZodString>;
-        pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-        omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-        command: z.ZodString;
-        packageName: z.ZodOptional<z.ZodString>;
-        requiredEnv: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"mcpSseSkill">;
-        description: z.ZodOptional<z.ZodString>;
-        rule: z.ZodOptional<z.ZodString>;
-        pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-        omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-        endpoint: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"interactiveSkill">;
-        description: z.ZodOptional<z.ZodString>;
-        rule: z.ZodOptional<z.ZodString>;
-        tools: z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodObject<{
-            description: z.ZodOptional<z.ZodString>;
-            inputJsonSchema: z.ZodString;
-        }, z.core.$strip>>, z.ZodTransform<{
-            [k: string]: {
-                name: string;
-                inputJsonSchema: string;
-                description?: string | undefined;
-            };
-        }, Record<string, {
-            inputJsonSchema: string;
-            description?: string | undefined;
-        }>>>;
-    }, z.core.$strip>], "type">>>>, z.ZodTransform<{
-        [k: string]: {
-            type: "mcpStdioSkill";
-            name: string;
-            pick: string[];
-            omit: string[];
-            command: string;
-            args: string[];
-            requiredEnv: string[];
-            description?: string | undefined;
-            rule?: string | undefined;
-            packageName?: string | undefined;
-        } | {
-            type: "mcpSseSkill";
-            name: string;
-            pick: string[];
-            omit: string[];
-            endpoint: string;
-            description?: string | undefined;
-            rule?: string | undefined;
-        } | {
-            type: "interactiveSkill";
-            name: string;
-            tools: {
-                [k: string]: {
-                    name: string;
-                    inputJsonSchema: string;
-                    description?: string | undefined;
-                };
-            };
-            description?: string | undefined;
-            rule?: string | undefined;
-        };
-    }, Record<string, {
-        type: "mcpStdioSkill";
-        args: string[];
-        pick: string[];
-        omit: string[];
-        command: string;
-        requiredEnv: string[];
-        description?: string | undefined;
-        rule?: string | undefined;
-        packageName?: string | undefined;
-    } | {
-        type: "mcpSseSkill";
-        pick: string[];
-        omit: string[];
-        endpoint: string;
-        description?: string | undefined;
-        rule?: string | undefined;
-    } | {
-        type: "interactiveSkill";
-        tools: {
-            [k: string]: {
-                name: string;
-                inputJsonSchema: string;
-                description?: string | undefined;
-            };
-        };
-        description?: string | undefined;
-        rule?: string | undefined;
-    }>>>;
-    delegates: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-    tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-    minRuntimeVersion: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<`v${number}.${number}`, string>>>;
-    providerTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    providerSkills: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"builtin">;
-        skillId: z.ZodEnum<{
-            pdf: "pdf";
-            docx: "docx";
-            pptx: "pptx";
-            xlsx: "xlsx";
-        }>;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"custom">;
-        name: z.ZodString;
-        definition: z.ZodString;
-    }, z.core.$strip>], "type">>>;
-    providerToolOptions: z.ZodOptional<z.ZodObject<{
-        webSearch: z.ZodOptional<z.ZodObject<{
-            maxUses: z.ZodOptional<z.ZodNumber>;
-            allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
-        webFetch: z.ZodOptional<z.ZodObject<{
-            maxUses: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        fileSearch: z.ZodOptional<z.ZodObject<{
-            vectorStoreIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            maxNumResults: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-/**
- * Expert schema with delegation rule validation.
- * Rejects self-delegation, out-of-scope delegates, and delegate-to-own-coordinator.
- */
-export declare const expertSchema: z.ZodObject<{
-    key: z.ZodString;
-    name: z.ZodString;
-    version: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    instruction: z.ZodString;
-    skills: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"mcpStdioSkill">;
-        description: z.ZodOptional<z.ZodString>;
-        args: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-        rule: z.ZodOptional<z.ZodString>;
-        pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-        omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-        command: z.ZodString;
-        packageName: z.ZodOptional<z.ZodString>;
-        requiredEnv: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"mcpSseSkill">;
-        description: z.ZodOptional<z.ZodString>;
-        rule: z.ZodOptional<z.ZodString>;
-        pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-        omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-        endpoint: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"interactiveSkill">;
-        description: z.ZodOptional<z.ZodString>;
-        rule: z.ZodOptional<z.ZodString>;
-        tools: z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodObject<{
-            description: z.ZodOptional<z.ZodString>;
-            inputJsonSchema: z.ZodString;
-        }, z.core.$strip>>, z.ZodTransform<{
-            [k: string]: {
-                name: string;
-                inputJsonSchema: string;
-                description?: string | undefined;
-            };
-        }, Record<string, {
-            inputJsonSchema: string;
-            description?: string | undefined;
-        }>>>;
-    }, z.core.$strip>], "type">>>>, z.ZodTransform<{
-        [k: string]: {
-            type: "mcpStdioSkill";
-            name: string;
-            pick: string[];
-            omit: string[];
-            command: string;
-            args: string[];
-            requiredEnv: string[];
-            description?: string | undefined;
-            rule?: string | undefined;
-            packageName?: string | undefined;
-        } | {
-            type: "mcpSseSkill";
-            name: string;
-            pick: string[];
-            omit: string[];
-            endpoint: string;
-            description?: string | undefined;
-            rule?: string | undefined;
-        } | {
-            type: "interactiveSkill";
-            name: string;
-            tools: {
-                [k: string]: {
-                    name: string;
-                    inputJsonSchema: string;
-                    description?: string | undefined;
-                };
-            };
-            description?: string | undefined;
-            rule?: string | undefined;
-        };
-    }, Record<string, {
-        type: "mcpStdioSkill";
-        args: string[];
-        pick: string[];
-        omit: string[];
-        command: string;
-        requiredEnv: string[];
-        description?: string | undefined;
-        rule?: string | undefined;
-        packageName?: string | undefined;
-    } | {
-        type: "mcpSseSkill";
-        pick: string[];
-        omit: string[];
-        endpoint: string;
-        description?: string | undefined;
-        rule?: string | undefined;
-    } | {
-        type: "interactiveSkill";
-        tools: {
-            [k: string]: {
-                name: string;
-                inputJsonSchema: string;
-                description?: string | undefined;
-            };
-        };
-        description?: string | undefined;
-        rule?: string | undefined;
-    }>>>;
-    delegates: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-    tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-    minRuntimeVersion: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<`v${number}.${number}`, string>>>;
-    providerTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    providerSkills: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"builtin">;
-        skillId: z.ZodEnum<{
-            pdf: "pdf";
-            docx: "docx";
-            pptx: "pptx";
-            xlsx: "xlsx";
-        }>;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"custom">;
-        name: z.ZodString;
-        definition: z.ZodString;
-    }, z.core.$strip>], "type">>>;
-    providerToolOptions: z.ZodOptional<z.ZodObject<{
-        webSearch: z.ZodOptional<z.ZodObject<{
-            maxUses: z.ZodOptional<z.ZodNumber>;
-            allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
-        webFetch: z.ZodOptional<z.ZodObject<{
-            maxUses: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        fileSearch: z.ZodOptional<z.ZodObject<{
-            vectorStoreIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            maxNumResults: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-//# sourceMappingURL=expert.d.ts.map

package/dist/src/schemas/expert.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"expert.d.ts","sourceRoot":"","sources":["../../../src/schemas/expert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AASvB,OAAO,KAAK,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAEtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,OAAO,KAAK,EAAgD,KAAK,EAAE,MAAM,YAAY,CAAA;AAGrF;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB,kFAAkF;IAClF,GAAG,EAAE,MAAM,CAAA;IACX,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,8BAA8B;IAC9B,OAAO,EAAE,MAAM,CAAA;IACf,0DAA0D;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,wDAAwD;IACxD,WAAW,EAAE,MAAM,CAAA;IACnB,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IAC7B,sDAAsD;IACtD,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,4CAA4C;IAC5C,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,0DAA0D;IAC1D,iBAAiB,EAAE,cAAc,CAAA;IACjC,kFAAkF;IAClF,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;IACxB,2CAA2C;IAC3C,cAAc,CAAC,EAAE,sBAAsB,EAAE,CAAA;IACzC,sEAAsE;IACtE,mBAAmB,CAAC,EAAE,mBAAmB,CAAA;CAC1C;AAOD;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqD3B,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKvB,CAAA"}

package/dist/src/schemas/expert.js

@@ -1,70 +0,0 @@
-import { z } from "zod";
-import { expertKeyRegex, expertNameRegex, expertVersionRegex, maxExpertNameLength, tagNameRegex, } from "../constants/constants.js";
-import { validateAllDelegations } from "../utils/expert-type.js";
-import { anthropicProviderSkillSchema, providerToolOptionsSchema } from "./provider-tools.js";
-import { runtimeVersionSchema } from "./runtime-version.js";
-import { interactiveSkillSchema, mcpSseSkillSchema, mcpStdioSkillSchema } from "./skill.js";
-/**
- * Base object schema for Expert. Use this for `.omit()` / `.pick()` operations.
- * For parsing with delegation validation, use `expertSchema` instead.
- */
-export const expertBaseSchema = z.object({
-    key: z.string().regex(expertKeyRegex).min(1),
-    name: z.string().regex(expertNameRegex).min(1).max(maxExpertNameLength),
-    version: z.string().regex(expertVersionRegex),
-    description: z
-        .string()
-        .max(1024 * 2)
-        .optional(),
-    instruction: z
-        .string()
-        .min(1)
-        .max(1024 * 20),
-    skills: z
-        .record(z.string(), z.discriminatedUnion("type", [
-        mcpStdioSkillSchema.omit({ name: true }),
-        mcpSseSkillSchema.omit({ name: true }),
-        interactiveSkillSchema.omit({ name: true }),
-    ]))
-        .optional()
-        .default({
-        "@perstack/base": {
-            type: "mcpStdioSkill",
-            description: "Base skill",
-            command: "npx",
-            args: ["-y", "@perstack/base"],
-            pick: [],
-            omit: [],
-            requiredEnv: [],
-        },
-    })
-        .transform((skills) => {
-        return Object.fromEntries(Object.entries(skills).map(([key, skillWithoutName]) => [
-            key,
-            z
-                .discriminatedUnion("type", [
-                mcpStdioSkillSchema,
-                mcpSseSkillSchema,
-                interactiveSkillSchema,
-            ])
-                .parse({ ...skillWithoutName, name: key }),
-        ]));
-    }),
-    delegates: z.array(z.string().regex(expertKeyRegex).min(1)).optional().default([]),
-    tags: z.array(z.string().regex(tagNameRegex).min(1)).optional().default([]),
-    minRuntimeVersion: runtimeVersionSchema.default("v1.0"),
-    providerTools: z.array(z.string()).optional(),
-    providerSkills: z.array(anthropicProviderSkillSchema).optional(),
-    providerToolOptions: providerToolOptionsSchema,
-});
-/**
- * Expert schema with delegation rule validation.
- * Rejects self-delegation, out-of-scope delegates, and delegate-to-own-coordinator.
- */
-export const expertSchema = expertBaseSchema.superRefine((data, ctx) => {
-    const errors = validateAllDelegations(data.key, data.delegates);
-    for (const error of errors) {
-        ctx.addIssue({ code: z.ZodIssueCode.custom, message: error, path: ["delegates"] });
-    }
-});
-//# sourceMappingURL=expert.js.map

package/dist/src/schemas/expert.js.map

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

package/dist/src/schemas/job.d.ts

@@ -1,44 +0,0 @@
-import { z } from "zod";
-import type { RuntimeVersion } from "./runtime-version.js";
-import type { Usage } from "./usage.js";
-export type JobStatus = "running" | "completed" | "stoppedByInteractiveTool" | "stoppedByError" | "stoppedByCancellation";
-export declare const jobStatusSchema: z.ZodEnum<{
-    completed: "completed";
-    stoppedByInteractiveTool: "stoppedByInteractiveTool";
-    stoppedByError: "stoppedByError";
-    stoppedByCancellation: "stoppedByCancellation";
-    running: "running";
-}>;
-export interface Job {
-    id: string;
-    status: JobStatus;
-    coordinatorExpertKey: string;
-    runtimeVersion: RuntimeVersion;
-    totalSteps: number;
-    usage: Usage;
-    startedAt: number;
-    finishedAt?: number;
-}
-export declare const jobSchema: z.ZodObject<{
-    id: z.ZodString;
-    status: z.ZodEnum<{
-        completed: "completed";
-        stoppedByInteractiveTool: "stoppedByInteractiveTool";
-        stoppedByError: "stoppedByError";
-        stoppedByCancellation: "stoppedByCancellation";
-        running: "running";
-    }>;
-    coordinatorExpertKey: z.ZodString;
-    runtimeVersion: z.ZodPipe<z.ZodString, z.ZodTransform<`v${number}.${number}`, string>>;
-    totalSteps: z.ZodNumber;
-    usage: z.ZodObject<{
-        inputTokens: z.ZodNumber;
-        outputTokens: z.ZodNumber;
-        reasoningTokens: z.ZodNumber;
-        totalTokens: z.ZodNumber;
-        cachedInputTokens: z.ZodNumber;
-    }, z.core.$strip>;
-    startedAt: z.ZodNumber;
-    finishedAt: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-//# sourceMappingURL=job.d.ts.map

package/dist/src/schemas/job.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"job.d.ts","sourceRoot":"","sources":["../../../src/schemas/job.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAGvC,MAAM,MAAM,SAAS,GACjB,SAAS,GACT,WAAW,GACX,0BAA0B,GAC1B,gBAAgB,GAChB,uBAAuB,CAAA;AAE3B,eAAO,MAAM,eAAe;;;;;;EAM1B,CAAA;AAEF,MAAM,WAAW,GAAG;IAClB,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,SAAS,CAAA;IACjB,oBAAoB,EAAE,MAAM,CAAA;IAC5B,cAAc,EAAE,cAAc,CAAA;IAC9B,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,KAAK,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;iBASpB,CAAA"}

package/dist/src/schemas/job.js

@@ -1,22 +0,0 @@
-import { z } from "zod";
-import { runtimeVersionSchema } from "./runtime-version.js";
-import { usageSchema } from "./usage.js";
-export const jobStatusSchema = z.enum([
-    "running",
-    "completed",
-    "stoppedByInteractiveTool",
-    "stoppedByError",
-    "stoppedByCancellation",
-]);
-export const jobSchema = z.object({
-    id: z.string(),
-    status: jobStatusSchema,
-    coordinatorExpertKey: z.string(),
-    runtimeVersion: runtimeVersionSchema,
-    totalSteps: z.number(),
-    usage: usageSchema,
-    startedAt: z.number(),
-    finishedAt: z.number().optional(),
-});
-jobSchema;
-//# sourceMappingURL=job.js.map

package/dist/src/schemas/job.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"job.js","sourceRoot":"","sources":["../../../src/schemas/job.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAE3D,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AASxC,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,IAAI,CAAC;IACpC,SAAS;IACT,WAAW;IACX,0BAA0B;IAC1B,gBAAgB;IAChB,uBAAuB;CACxB,CAAC,CAAA;AAaF,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC;IAChC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,MAAM,EAAE,eAAe;IACvB,oBAAoB,EAAE,CAAC,CAAC,MAAM,EAAE;IAChC,cAAc,EAAE,oBAAoB;IACpC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,KAAK,EAAE,WAAW;IAClB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;IACrB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAClC,CAAC,CAAA;AACF,SAAkC,CAAA"}

package/dist/src/schemas/lockfile.d.ts

@@ -1,143 +0,0 @@
-import { z } from "zod";
-import type { Skill } from "./skill.js";
-export interface LockfileToolDefinition {
-    skillName: string;
-    name: string;
-    description?: string;
-    inputSchema: Record<string, unknown>;
-}
-export declare const lockfileToolDefinitionSchema: z.ZodObject<{
-    skillName: z.ZodString;
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strip>;
-export interface LockfileExpert {
-    key: string;
-    name: string;
-    version: string;
-    description?: string;
-    instruction: string;
-    skills: Record<string, Skill>;
-    delegates: string[];
-    tags: string[];
-    toolDefinitions: LockfileToolDefinition[];
-}
-export declare const lockfileExpertSchema: z.ZodObject<{
-    key: z.ZodString;
-    name: z.ZodString;
-    version: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    instruction: z.ZodString;
-    skills: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
-        type: z.ZodLiteral<"mcpStdioSkill">;
-        name: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        rule: z.ZodOptional<z.ZodString>;
-        pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-        omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-        command: z.ZodString;
-        packageName: z.ZodOptional<z.ZodString>;
-        args: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-        requiredEnv: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"mcpSseSkill">;
-        name: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        rule: z.ZodOptional<z.ZodString>;
-        pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-        omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-        endpoint: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        type: z.ZodLiteral<"interactiveSkill">;
-        name: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        rule: z.ZodOptional<z.ZodString>;
-        tools: z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodObject<{
-            description: z.ZodOptional<z.ZodString>;
-            inputJsonSchema: z.ZodString;
-        }, z.core.$strip>>, z.ZodTransform<{
-            [k: string]: {
-                name: string;
-                inputJsonSchema: string;
-                description?: string | undefined;
-            };
-        }, Record<string, {
-            inputJsonSchema: string;
-            description?: string | undefined;
-        }>>>;
-    }, z.core.$strip>], "type">>;
-    delegates: z.ZodArray<z.ZodString>;
-    tags: z.ZodArray<z.ZodString>;
-    toolDefinitions: z.ZodArray<z.ZodObject<{
-        skillName: z.ZodString;
-        name: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export interface Lockfile {
-    version: "1";
-    generatedAt: number;
-    configPath: string;
-    experts: Record<string, LockfileExpert>;
-}
-export declare const lockfileSchema: z.ZodObject<{
-    version: z.ZodLiteral<"1">;
-    generatedAt: z.ZodNumber;
-    configPath: z.ZodString;
-    experts: z.ZodRecord<z.ZodString, z.ZodObject<{
-        key: z.ZodString;
-        name: z.ZodString;
-        version: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        instruction: z.ZodString;
-        skills: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
-            type: z.ZodLiteral<"mcpStdioSkill">;
-            name: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-            rule: z.ZodOptional<z.ZodString>;
-            pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-            omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-            command: z.ZodString;
-            packageName: z.ZodOptional<z.ZodString>;
-            args: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-            requiredEnv: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-        }, z.core.$strip>, z.ZodObject<{
-            type: z.ZodLiteral<"mcpSseSkill">;
-            name: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-            rule: z.ZodOptional<z.ZodString>;
-            pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-            omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
-            endpoint: z.ZodString;
-        }, z.core.$strip>, z.ZodObject<{
-            type: z.ZodLiteral<"interactiveSkill">;
-            name: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-            rule: z.ZodOptional<z.ZodString>;
-            tools: z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodObject<{
-                description: z.ZodOptional<z.ZodString>;
-                inputJsonSchema: z.ZodString;
-            }, z.core.$strip>>, z.ZodTransform<{
-                [k: string]: {
-                    name: string;
-                    inputJsonSchema: string;
-                    description?: string | undefined;
-                };
-            }, Record<string, {
-                inputJsonSchema: string;
-                description?: string | undefined;
-            }>>>;
-        }, z.core.$strip>], "type">>;
-        delegates: z.ZodArray<z.ZodString>;
-        tags: z.ZodArray<z.ZodString>;
-        toolDefinitions: z.ZodArray<z.ZodObject<{
-            skillName: z.ZodString;
-            name: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-            inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-//# sourceMappingURL=lockfile.d.ts.map

package/dist/src/schemas/lockfile.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lockfile.d.ts","sourceRoot":"","sources":["../../../src/schemas/lockfile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAGvC,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACrC;AAED,eAAO,MAAM,4BAA4B;;;;;iBAKvC,CAAA;AAEF,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IAC7B,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,eAAe,EAAE,sBAAsB,EAAE,CAAA;CAC1C;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAU/B,CAAA;AAEF,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,GAAG,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;CACxC;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKzB,CAAA"}

package/dist/src/schemas/lockfile.js

@@ -1,26 +0,0 @@
-import { z } from "zod";
-import { skillSchema } from "./skill.js";
-export const lockfileToolDefinitionSchema = z.object({
-    skillName: z.string(),
-    name: z.string(),
-    description: z.string().optional(),
-    inputSchema: z.record(z.string(), z.unknown()),
-});
-export const lockfileExpertSchema = z.object({
-    key: z.string(),
-    name: z.string(),
-    version: z.string(),
-    description: z.string().optional(),
-    instruction: z.string(),
-    skills: z.record(z.string(), skillSchema),
-    delegates: z.array(z.string()),
-    tags: z.array(z.string()),
-    toolDefinitions: z.array(lockfileToolDefinitionSchema),
-});
-export const lockfileSchema = z.object({
-    version: z.literal("1"),
-    generatedAt: z.number(),
-    configPath: z.string(),
-    experts: z.record(z.string(), lockfileExpertSchema),
-});
-//# sourceMappingURL=lockfile.js.map

package/dist/src/schemas/lockfile.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"lockfile.js","sourceRoot":"","sources":["../../../src/schemas/lockfile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AASxC,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,CAAC;IACnD,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;IACrB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAClC,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;CAC/C,CAAC,CAAA;AAcF,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE;IACf,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAClC,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,WAAW,CAAC;IACzC,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC9B,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IACzB,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,4BAA4B,CAAC;CACvD,CAAC,CAAA;AASF,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC;IACrC,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC;IACvB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,oBAAoB,CAAC;CACpD,CAAC,CAAA"}