agent-skill-evals 0.1.0 → 0.1.1

package/dist/internal-services-5-mRgNls.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"internal-services-5-mRgNls.mjs","names":["parseYaml"],"sources":["../src/runtime-checks/check-set.ts","../src/assertion-entries.ts","../src/internal-services.ts"],"sourcesContent":["export const RUNTIME_CHECK_TYPES = [\n  \"verifier.succeeds\",\n  \"verifier.fails\",\n  \"file.exists\",\n  \"file.created\",\n  \"file.contains\",\n  \"file.not_modified\",\n  \"file.changes_outside_scope\",\n  \"code.pattern_exists\",\n  \"code.no_pattern\",\n  \"tool.called\",\n  \"tool.not_called\",\n  \"skill.loaded\",\n] as const;\n\nexport type RuntimeCheckType = (typeof RUNTIME_CHECK_TYPES)[number];\n\nexport const DOUBLE_NEGATIVE_CHECK_TYPES = [\n  \"code.no_pattern\",\n  \"file.not_modified\",\n  \"tool.not_called\",\n] as const satisfies readonly RuntimeCheckType[];\n\nexport const runtimeCheckTypeSet = new Set<string>(RUNTIME_CHECK_TYPES);\nexport const doubleNegativeCheckTypeSet = new Set<string>(DOUBLE_NEGATIVE_CHECK_TYPES);\n","import * as Either from \"effect/Either\";\nimport * as Schema from \"effect/Schema\";\nimport { doubleNegativeCheckTypeSet } from \"./runtime-checks/check-set.js\";\nimport type { AssertionMode } from \"./internal-types.js\";\n\nexport interface AssertionEntry {\n  type: string;\n  args: unknown;\n}\n\nexport interface AssertionEntryError {\n  field: string;\n  index?: number;\n  reason: string;\n}\n\nexport interface ParsedAssertionEntries {\n  entries: AssertionEntry[];\n  errors: AssertionEntryError[];\n}\n\nexport interface RuntimeTestFieldEntries {\n  preconditions: AssertionEntry[];\n  should: AssertionEntry[];\n  should_not: AssertionEntry[];\n  errors: AssertionEntryError[];\n}\n\ninterface TypedEntry {\n  type?: unknown;\n  [key: string]: unknown;\n}\n\nconst RuntimeFieldArraySchema = Schema.Array(Schema.Unknown);\nconst EntryObjectSchema = Schema.Unknown.pipe(\n  Schema.filter(\n    (value): value is Record<string, unknown> =>\n      typeof value === \"object\" && value !== null && !Array.isArray(value),\n    { identifier: \"AssertionEntryObject\" },\n  ),\n);\nconst NonEmptyTypeSchema = Schema.String.pipe(\n  Schema.filter((value) => value.length > 0, { identifier: \"NonEmptyType\" }),\n);\n\n/**\n * Normalizes Promptfoo `vars.preconditions | should | should_not` entries.\n *\n * Supported forms:\n * - `\"file.exists\"`\n * - `{ type: \"file.exists\", path: \"app.js\" }`\n * - `{ \"file.exists\": { path: \"app.js\" } }`\n */\nexport function parseRuntimeTestFields(\n  vars: Record<string, unknown>,\n): RuntimeTestFieldEntries {\n  const preconditions = parseAssertionEntries(vars.preconditions, \"preconditions\", {\n    allowMissing: true,\n    mode: \"precondition\",\n  });\n  const should = parseAssertionEntries(vars.should, \"should\", {\n    allowMissing: true,\n    mode: \"should\",\n  });\n  const shouldNot = parseAssertionEntries(vars.should_not, \"should_not\", {\n    allowMissing: true,\n    mode: \"should_not\",\n  });\n  return {\n    preconditions: preconditions.entries,\n    should: should.entries,\n    should_not: shouldNot.entries,\n    errors: [...preconditions.errors, ...should.errors, ...shouldNot.errors],\n  };\n}\n\nexport function parseAssertionEntries(\n  raw: unknown,\n  field: string,\n  options: { allowMissing?: boolean; mode?: AssertionMode } = {},\n): ParsedAssertionEntries {\n  const entries: AssertionEntry[] = [];\n  const errors: AssertionEntryError[] = [];\n\n  if (raw === undefined || raw === null) {\n    if (!options.allowMissing) {\n      errors.push({ field, reason: \"must be an array of assertion entries\" });\n    }\n    return { entries, errors };\n  }\n\n  const rawEntries = Schema.decodeUnknownEither(RuntimeFieldArraySchema)(raw);\n  if (Either.isLeft(rawEntries)) {\n    return {\n      entries,\n      errors: [{ field, reason: \"must be an array of assertion entries\" }],\n    };\n  }\n\n  rawEntries.right.forEach((entry, index) => {\n    const parsed = parseAssertionEntry(entry, field, index);\n    if (\"error\" in parsed) {\n      errors.push(parsed.error);\n    } else {\n      if (\n        options.mode === \"should_not\" &&\n        doubleNegativeCheckTypeSet.has(parsed.entry.type)\n      ) {\n        errors.push({\n          field,\n          index,\n          reason: `\"${parsed.entry.type}\" must be declared under should, not should_not`,\n        });\n        return;\n      }\n      entries.push(parsed.entry);\n    }\n  });\n\n  return { entries, errors };\n}\n\nfunction parseAssertionEntry(\n  entry: unknown,\n  field: string,\n  index: number,\n): { entry: AssertionEntry } | { error: AssertionEntryError } {\n  if (typeof entry === \"string\") {\n    if (Either.isLeft(Schema.decodeUnknownEither(NonEmptyTypeSchema)(entry))) {\n      return { error: { field, index, reason: \"string entry must not be empty\" } };\n    }\n    return { entry: { type: entry, args: {} } };\n  }\n\n  const decodedObject = Schema.decodeUnknownEither(EntryObjectSchema)(entry);\n  if (Either.isLeft(decodedObject)) {\n    return {\n      error: {\n        field,\n        index,\n        reason: \"entry must be a string, { type: ... }, or shorthand object\",\n      },\n    };\n  }\n\n  const candidate = decodedObject.right as TypedEntry;\n  if (\"type\" in candidate) {\n    const type = Schema.decodeUnknownEither(NonEmptyTypeSchema)(candidate.type);\n    if (Either.isLeft(type)) {\n      return {\n        error: { field, index, reason: \"`type` must be a non-empty string\" },\n      };\n    }\n    return { entry: { type: type.right, args: candidate } };\n  }\n\n  const keys = Object.keys(candidate);\n  if (keys.length !== 1) {\n    return {\n      error: {\n        field,\n        index,\n        reason: \"shorthand assertion object must have exactly one key\",\n      },\n    };\n  }\n\n  const type = keys[0]!;\n  const args = candidate[type] ?? {};\n  if (args !== null && typeof args !== \"object\") {\n    return {\n      error: {\n        field,\n        index,\n        reason: `shorthand assertion \"${type}\" value must be an object`,\n      },\n    };\n  }\n  return { entry: { type, args } };\n}\n","import { constants } from \"node:fs\";\nimport * as PlatformFileSystem from \"@effect/platform/FileSystem\";\nimport * as NodeFileSystem from \"@effect/platform-node/NodeFileSystem\";\nimport * as Context from \"effect/Context\";\nimport * as Effect from \"effect/Effect\";\nimport * as Layer from \"effect/Layer\";\nimport { parse as parseYaml } from \"yaml\";\n\ninterface DirectoryEntry {\n  name: string;\n  isDirectory(): boolean;\n  isFile(): boolean;\n}\n\ninterface FileInfo {\n  mode: number;\n  isDirectory(): boolean;\n  isFile(): boolean;\n}\n\ninterface FileSystemService {\n  access(path: string, mode?: number): Effect.Effect<void, unknown>;\n  copyDirectory(source: string, destination: string): Effect.Effect<void, unknown>;\n  makeDirectory(path: string): Effect.Effect<void, unknown>;\n  makeTempDirectory(prefix: string): Effect.Effect<string, unknown>;\n  readFile(path: string): Effect.Effect<Buffer, unknown>;\n  readText(path: string): Effect.Effect<string, unknown>;\n  readDirectory(path: string): Effect.Effect<DirectoryEntry[], unknown>;\n  stat(path: string): Effect.Effect<FileInfo, unknown>;\n  writeText(path: string, contents: string): Effect.Effect<void, unknown>;\n}\n\ninterface EnvironmentService {\n  cwd: Effect.Effect<string>;\n  env: Effect.Effect<NodeJS.ProcessEnv>;\n}\n\ninterface YamlService {\n  parse(input: string): Effect.Effect<unknown, unknown>;\n}\n\nexport class FileSystem extends Context.Tag(\"agent-skill-evals/promptfoo/FileSystem\")<\n  FileSystem,\n  FileSystemService\n>() {}\n\nexport class Environment extends Context.Tag(\"agent-skill-evals/promptfoo/Environment\")<\n  Environment,\n  EnvironmentService\n>() {}\n\nexport class YamlParser extends Context.Tag(\"agent-skill-evals/promptfoo/YamlParser\")<\n  YamlParser,\n  YamlService\n>() {}\n\nfunction toFileInfo(info: PlatformFileSystem.File.Info): FileInfo {\n  return {\n    mode: info.mode,\n    isDirectory: () => info.type === \"Directory\",\n    isFile: () => info.type === \"File\",\n  };\n}\n\nfunction executableFromMode(mode: number): boolean {\n  return (mode & 0o111) !== 0;\n}\n\nconst PlatformBackedFileSystemLive = Layer.effect(\n  FileSystem,\n  Effect.gen(function* () {\n    const fs = yield* PlatformFileSystem.FileSystem;\n\n    const statFile = (path: string) => fs.stat(path).pipe(Effect.map(toFileInfo));\n\n    return {\n      access: (path: string, mode?: number) => {\n        const readable = mode === undefined ? undefined : (mode & constants.R_OK) !== 0;\n        const writable = mode === undefined ? undefined : (mode & constants.W_OK) !== 0;\n        const executable = mode === undefined ? false : (mode & constants.X_OK) !== 0;\n        const baseAccess = fs.access(path, {\n          ok: true,\n          readable,\n          writable,\n        });\n        if (!executable) return baseAccess;\n        return baseAccess.pipe(\n          Effect.zipRight(statFile(path)),\n          Effect.flatMap((info) =>\n            executableFromMode(info.mode)\n              ? Effect.void\n              : Effect.fail(new Error(`Path is not executable: ${path}`)),\n          ),\n        );\n      },\n      copyDirectory: (source: string, destination: string) =>\n        fs.copy(source, destination),\n      makeDirectory: (path: string) => fs.makeDirectory(path, { recursive: true }),\n      makeTempDirectory: (prefix: string) => fs.makeTempDirectory({ prefix }),\n      readFile: (path: string) => fs.readFile(path).pipe(Effect.map(Buffer.from)),\n      readText: (path: string) => fs.readFileString(path),\n      readDirectory: (path: string) =>\n        fs.readDirectory(path).pipe(\n          Effect.flatMap((names) =>\n            Effect.forEach(names, (name) =>\n              fs.stat(`${path}/${name}`).pipe(\n                Effect.map((info): DirectoryEntry => ({\n                  name,\n                  isDirectory: () => info.type === \"Directory\",\n                  isFile: () => info.type === \"File\",\n                })),\n              ),\n            ),\n          ),\n        ),\n      stat: statFile,\n      writeText: (path: string, contents: string) => fs.writeFileString(path, contents),\n    };\n  }),\n);\n\nexport const NodeFileSystemLive = PlatformBackedFileSystemLive.pipe(\n  Layer.provide(NodeFileSystem.layer),\n);\n\nexport const NodeEnvironmentLive = Layer.succeed(Environment, {\n  cwd: Effect.sync(() => process.cwd()),\n  env: Effect.sync(() => ({ ...process.env })),\n});\n\nexport const YamlParserLive = Layer.succeed(YamlParser, {\n  parse: (input) =>\n    Effect.try({\n      try: () => parseYaml(input),\n      catch: (error) => error,\n    }),\n});\n\nexport const NodeServicesLive = Layer.mergeAll(\n  NodeFileSystemLive,\n  NodeEnvironmentLive,\n  YamlParserLive,\n);\n\nexport function pathExists(path: string): Effect.Effect<boolean, never, FileSystem> {\n  return Effect.gen(function* () {\n    const fs = yield* FileSystem;\n    return yield* fs.stat(path).pipe(\n      Effect.as(true),\n      Effect.catchAll(() => Effect.succeed(false)),\n    );\n  });\n}\n\nexport function pathExecutable(path: string): Effect.Effect<boolean, never, FileSystem> {\n  return Effect.gen(function* () {\n    const fs = yield* FileSystem;\n    return yield* fs.access(path, constants.X_OK).pipe(\n      Effect.as(true),\n      Effect.catchAll(() => Effect.succeed(false)),\n    );\n  });\n}\n"],"mappings":"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"}

package/dist/internal-services-DbsekQ_K.d.mts

@@ -1,76 +0,0 @@
-//#region src/evidence-types.d.ts
-declare const EVIDENCE_SCHEMA_VERSION = "agent-skill-evals.evidence.v1";
-interface CommandEvent {
-  command: string;
-  args: string[];
-  exitCode: number;
-  signal?: string;
-  stdout?: string;
-  stderr?: string;
-  startedAt: number;
-  durationMs: number;
-}
-interface FileEvent {
-  path: string;
-  op: "create" | "modify" | "delete";
-}
-interface ToolCallEvent {
-  tool: string;
-  provider?: string;
-  server?: string;
-  args?: unknown;
-  result?: unknown;
-  startedAt: number;
-  durationMs: number;
-}
-interface SkillLoadEvent {
-  skill: string;
-  delivery: "native" | "mcp";
-  provider?: string;
-  server?: string;
-  source?: string;
-  startedAt: number;
-}
-interface Usage {
-  inputTokens?: number;
-  outputTokens?: number;
-  totalTokens?: number;
-  cacheReadTokens?: number;
-  cacheWriteTokens?: number;
-}
-interface RunSummary {
-  runDir: string;
-  worldPath: string;
-  fixture: string;
-  durationMs?: number;
-}
-interface EvidenceSnapshot {
-  schemaVersion: typeof EVIDENCE_SCHEMA_VERSION;
-  output: string;
-  run: RunSummary;
-  commands: CommandEvent[];
-  filesWritten: FileEvent[];
-  toolCalls: ToolCallEvent[];
-  skillsLoaded: SkillLoadEvent[];
-  usage: Usage;
-  extensions?: Record<string, unknown>;
-}
-//#endregion
-//#region src/internal-types.d.ts
-interface AgentSkillEvalsAssertionResult {
-  pass: boolean;
-  score: number;
-  reason: string;
-  componentResults?: AgentSkillEvalsAssertionResult[];
-  evidence?: unknown;
-}
-interface EvidenceHandle {
-  commands(): readonly CommandEvent[];
-  filesWritten(): readonly FileEvent[];
-  toolCalls(): readonly ToolCallEvent[];
-  skillsLoaded(): readonly SkillLoadEvent[];
-  usage(): Usage;
-}
-//#endregion
-export { FileEvent as a, Usage as c, EvidenceSnapshot as i, EvidenceHandle as n, SkillLoadEvent as o, CommandEvent as r, ToolCallEvent as s, AgentSkillEvalsAssertionResult as t };
-//# sourceMappingURL=internal-services-DbsekQ_K.d.mts.map

package/dist/internal-services-DbsekQ_K.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"internal-services-DbsekQ_K.d.mts","names":[],"sources":["../src/evidence-types.ts","../src/internal-types.ts"],"mappings":";cAAa,uBAAA;AAAA,UAEI,YAAA;EACf,OAAA;EACA,IAAA;EACA,QAAA;EACA,MAAA;EACA,MAAA;EACA,MAAA;EACA,SAAA;EACA,UAAA;AAAA;AAAA,UAGe,SAAA;EACf,IAAA;EACA,EAAA;AAAA;AAAA,UAGe,aAAA;EACf,IAAA;EACA,QAAA;EACA,MAAA;EACA,IAAA;EACA,MAAA;EACA,SAAA;EACA,UAAA;AAAA;AAAA,UAGe,cAAA;EACf,KAAA;EACA,QAAA;EACA,QAAA;EACA,MAAA;EACA,MAAA;EACA,SAAA;AAAA;AAAA,UAGe,KAAA;EACf,WAAA;EACA,YAAA;EACA,WAAA;EACA,eAAA;EACA,gBAAA;AAAA;AAAA,UAGe,UAAA;EACf,MAAA;EACA,SAAA;EACA,OAAA;EACA,UAAA;AAAA;AAAA,UAGe,gBAAA;EACf,aAAA,SAAsB,uBAAA;EACtB,MAAA;EACA,GAAA,EAAK,UAAA;EACL,QAAA,EAAU,YAAA;EACV,YAAA,EAAc,SAAA;EACd,SAAA,EAAW,aAAA;EACX,YAAA,EAAc,cAAA;EACd,KAAA,EAAO,KAAA;EACP,UAAA,GAAa,MAAA;AAAA;;;UClDE,8BAAA;EACf,IAAA;EACA,KAAA;EACA,MAAA;EACA,gBAAA,GAAmB,8BAAA;EACnB,QAAA;AAAA;AAAA,UAee,cAAA;EACf,QAAA,aAAqB,YAAA;EACrB,YAAA,aAAyB,SAAA;EACzB,SAAA,aAAsB,aAAA;EACtB,YAAA,aAAyB,cAAA;EACzB,KAAA,IAAS,KAAA;AAAA"}

package/dist/skill-checks/index.d.mts

@@ -1,113 +0,0 @@
-import { t as AssertionEntryError } from "../assertion-entries-CfmNt-fp.mjs";
-//#region src/skill-checks/skill.d.ts
-interface SkillFrontmatter {
-  name?: string;
-  description?: string;
-  [key: string]: unknown;
-}
-interface ParsedSkill {
-  /** Absolute path to the SKILL.md file. */
-  skillMdPath: string;
-  /** Absolute path to the skill folder (parent of SKILL.md). */
-  skillDir: string;
-  frontmatter: SkillFrontmatter;
-  /** Raw markdown body (after frontmatter). */
-  body: string;
-  /** Total lines in SKILL.md (including frontmatter). */
-  totalLines: number;
-  /** Relative paths referenced from SKILL.md (markdown links + script paths). */
-  references: string[];
-  /** Subset of references that don't exist on disk. */
-  missingReferences: string[];
-}
-declare function parseSkillMd(skillMdPath: string): Promise<ParsedSkill>;
-//#endregion
-//#region src/skill-checks/tests-pack.d.ts
-interface ParsedTest {
-  /** Absolute path of the YAML file containing this test. */
-  filePath: string;
-  description?: string;
-  vars: Record<string, unknown>;
-  /** Effect-type strings referenced by preconditions/should/should_not. */
-  effectTypes: string[];
-  /** Whether `vars.fixture` was set (or `fixtureless` flagged). */
-  hasFixture: boolean;
-  /** True if the test is `kind: negative` (or has no positive should + has should_not). */
-  isNegative: boolean;
-  /** True if the test declares any precondition. */
-  hasPrecondition: boolean;
-  /** True if the test declares an Agent Skill Evals token budget assertion. */
-  hasTokenBudget: boolean;
-  /** True if the file or vars marks the test as draft. */
-  isDraft: boolean;
-  /** Authoring diagnostics for malformed Agent Skill Evals assertion entries. */
-  entryErrors: AssertionEntryError[];
-}
-interface ParsedTestsPack {
-  /** YAML files matched by `testsGlob`. */
-  matchedFiles: string[];
-  /** All test cases discovered. */
-  tests: ParsedTest[];
-  /** Files that failed to parse (with error messages). */
-  parseErrors: Array<{
-    filePath: string;
-    error: string;
-  }>;
-  /** Verifier scripts referenced by `verifier.succeeds`/`verifier.fails`. */
-  verifierScripts: string[];
-  /** Verifier scripts that don't exist on disk. */
-  missingVerifierScripts: string[];
-  /** Verifier scripts that exist but are not executable by the current user. */
-  nonExecutableVerifierScripts: string[];
-  /** Fixture paths referenced by tests. */
-  fixturePaths: string[];
-  /** Fixture paths that don't exist on disk. */
-  missingFixturePaths: string[];
-  /** Effect types not in the supplied known-types set. */
-  unresolvedEffectTypes: string[];
-}
-declare function parseTestsPack(input: {
-  testsGlob: string;
-  baseDir: string;
-  knownEffectTypes: ReadonlySet<string>;
-}): Promise<ParsedTestsPack>;
-//#endregion
-//#region src/skill-checks/index.d.ts
-interface StaticProviderConfig {
-  /** Override for the cwd Promptfoo was launched from. */
-  baseDir?: string;
-}
-interface PromptfooContext {
-  vars?: Record<string, unknown>;
-  test?: {
-    vars?: Record<string, unknown>;
-  };
-}
-interface ProviderResponse {
-  output: string;
-  metadata?: Record<string, unknown>;
-  error?: string;
-}
-interface StaticProviderMetadata {
-  skill: ParsedSkill | null;
-  tests: ParsedTestsPack | null;
-  /** Combined missing files: skill references + verifier scripts + fixtures. */
-  missingFiles: string[];
-  /** Effect types referenced by tests but not in `knownEffectTypes`. */
-  unresolvedEffectTypes: string[];
-  warnings: string[];
-}
-declare class AgentSkillEvalsStaticProvider {
-  config: StaticProviderConfig;
-  private readonly configError?;
-  id: () => string;
-  constructor(options?: {
-    config?: StaticProviderConfig;
-    id?: string;
-  });
-  callApi(_prompt: string, context?: PromptfooContext): Promise<ProviderResponse>;
-  private callApiEffect;
-}
-//#endregion
-export { AgentSkillEvalsStaticProvider, AgentSkillEvalsStaticProvider as default, type ParsedSkill, type ParsedTestsPack, StaticProviderConfig, StaticProviderMetadata, parseSkillMd, parseTestsPack };
-//# sourceMappingURL=index.d.mts.map

package/dist/skill-checks/index.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/skill-checks/skill.ts","../../src/skill-checks/tests-pack.ts","../../src/skill-checks/index.ts"],"mappings":";;UASiB,gBAAA;EACf,IAAA;EACA,WAAA;EAAA,CACC,GAAA;AAAA;AAAA,UAGc,WAAA;EANgB;EAQ/B,WAAA;EANA;EAQA,QAAA;EACA,WAAA,EAAa,gBAAA;EARD;EAUZ,IAAA;EAP0B;EAS1B,UAAA;EAJ6B;EAM7B,UAAA;EAPA;EASA,iBAAA;AAAA;AAAA,iBAKoB,YAAA,CAAa,WAAA,WAAsB,OAAA,CAAQ,WAAA;;;UChBhD,UAAA;;EAEf,QAAA;EACA,WAAA;EACA,IAAA,EAAM,MAAA;EDZyB;ECc/B,WAAA;EDZA;ECcA,UAAA;EDbY;ECeZ,UAAA;EDZe;ECcf,eAAA;;EAEA,cAAA;EDdA;ECgBA,OAAA;EDbA;ECeA,WAAA,EAAa,mBAAA;AAAA;AAAA,UAGE,eAAA;EDZf;ECcA,YAAA;EDZiB;ECcjB,KAAA,EAAO,UAAA;EDTa;ECWpB,WAAA,EAAa,KAAA;IAAQ,QAAA;IAAkB,KAAA;EAAA;EDXgB;ECavD,eAAA;EDb0E;ECe1E,sBAAA;;EAEA,4BAAA;;EAEA,YAAA;EAnCyB;EAqCzB,mBAAA;EAnBgC;EAqBhC,qBAAA;AAAA;AAAA,iBAGoB,cAAA,CAAe,KAAA;EACnC,SAAA;EACA,OAAA;EACA,gBAAA,EAAkB,WAAA;AAAA,IAChB,OAAA,CAAQ,eAAA;;;UChDK,oBAAA;;EAEf,OAAA;AAAA;AAAA,UAOQ,gBAAA;EACR,IAAA,GAAO,MAAA;EACP,IAAA;IAAS,IAAA,GAAO,MAAA;EAAA;AAAA;AAAA,UAGR,gBAAA;EACR,MAAA;EACA,QAAA,GAAW,MAAA;EACX,KAAA;AAAA;AAAA,UAGe,sBAAA;EACf,KAAA,EAAO,WAAA;EACP,KAAA,EAAO,eAAA;EFjBP;EEmBA,YAAA;EFjBA;EEmBA,qBAAA;EACA,QAAA;AAAA;AAAA,cAGI,6BAAA;EACJ,MAAA,EAAQ,oBAAA;EAAA,iBACS,WAAA;EACjB,EAAA;cAEY,OAAA;IAAW,MAAA,GAAS,oBAAA;IAAsB,EAAA;EAAA;EAYhD,OAAA,CACJ,OAAA,UACA,OAAA,GAAS,gBAAA,GACR,OAAA,CAAQ,gBAAA;EAAA,QAMH,aAAA;AAAA"}

package/dist/skill-checks/index.mjs

@@ -1,408 +0,0 @@
-import { a as pathExecutable, c as parseRuntimeTestFields, i as YamlParser, l as RUNTIME_CHECK_TYPES, n as FileSystem, o as pathExists, r as NodeServicesLive, s as parseAssertionEntries, t as Environment } from "../internal-services-5-mRgNls.mjs";
-import { dirname, isAbsolute, join, resolve } from "node:path";
-import * as Either from "effect/Either";
-import * as Effect from "effect/Effect";
-import * as ParseResult from "effect/ParseResult";
-import * as Schema from "effect/Schema";
-//#region src/skill-checks/skill.ts
-const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
-async function parseSkillMd(skillMdPath) {
-	return Effect.runPromise(parseSkillMdEffect(skillMdPath).pipe(Effect.provide(NodeServicesLive)));
-}
-function parseSkillMdEffect(skillMdPath) {
-	return Effect.gen(function* () {
-		const skillDir = dirname(skillMdPath);
-		const fs = yield* FileSystem;
-		const yaml = yield* YamlParser;
-		const raw = yield* fs.readText(skillMdPath);
-		const totalLines = raw.split(/\r?\n/).length;
-		let frontmatter = {};
-		let body = raw;
-		const fmMatch = raw.match(FRONTMATTER_RE);
-		if (fmMatch) {
-			const parsed = yield* yaml.parse(fmMatch[1]);
-			if (parsed && typeof parsed === "object") frontmatter = parsed;
-			body = raw.slice(fmMatch[0].length);
-		}
-		const references = extractReferences(body);
-		const missingReferences = [];
-		for (const ref of references) if (!(yield* pathExists(isAbsolute(ref) ? ref : resolve(skillDir, ref)))) missingReferences.push(ref);
-		return {
-			skillMdPath,
-			skillDir,
-			frontmatter,
-			body,
-			totalLines,
-			references,
-			missingReferences
-		};
-	});
-}
-/**
-* Extract relative paths from a SKILL.md body. Captures:
-*   - Markdown links: [text](path)
-*   - Bare relative paths in code/inline-code: ./foo, ../foo, foo/bar.sh
-* Skips http(s):// URLs.
-*/
-function extractReferences(body) {
-	const refs = /* @__PURE__ */ new Set();
-	const linkRe = /\[[^\]]*\]\(([^)\s]+)\)/g;
-	let m;
-	while ((m = linkRe.exec(body)) !== null) {
-		const target = m[1];
-		if (target.startsWith("http://") || target.startsWith("https://")) continue;
-		if (target.startsWith("#")) continue;
-		refs.add(target);
-	}
-	const codeRe = /`((?:\.{1,2}\/)?[a-zA-Z0-9_./-]+\.[a-zA-Z0-9]{1,5})`/g;
-	while ((m = codeRe.exec(body)) !== null) {
-		const target = m[1];
-		if (target.includes("://")) continue;
-		refs.add(target);
-	}
-	return [...refs];
-}
-//#endregion
-//#region src/skill-checks/schemas.ts
-const UnknownRecordSchema = Schema.Unknown.pipe(Schema.filter((value) => isRecord(value), {
-	identifier: "UnknownRecord",
-	message: () => "must be an object"
-}));
-const UnknownArraySchema = Schema.Array(Schema.Unknown);
-function decodeTestPackDocument(value) {
-	if (Array.isArray(value)) try {
-		return { cases: Schema.decodeUnknownSync(UnknownArraySchema)(value) };
-	} catch (err) {
-		return {
-			cases: [],
-			parseError: schemaErrorMessage(err)
-		};
-	}
-	if (decodeRecord(value) !== null) return { cases: [value] };
-	return {
-		cases: [],
-		parseError: "test pack document must be an object or array of objects"
-	};
-}
-function decodeStaticTestCase(value) {
-	const caseRecord = decodeRecord(value);
-	if (caseRecord === null) return {
-		caseRecord: {},
-		vars: {},
-		entryErrors: [{
-			field: "case",
-			reason: "must be an object"
-		}]
-	};
-	const rawVars = caseRecord.vars;
-	if (rawVars === void 0 || rawVars === null) return {
-		caseRecord,
-		vars: {},
-		entryErrors: []
-	};
-	const vars = decodeRecord(rawVars);
-	if (vars === null) return {
-		caseRecord,
-		vars: {},
-		entryErrors: [{
-			field: "vars",
-			reason: "must be an object"
-		}]
-	};
-	return {
-		caseRecord,
-		vars,
-		entryErrors: []
-	};
-}
-function decodeRecord(value) {
-	try {
-		return Schema.decodeUnknownSync(UnknownRecordSchema)(value);
-	} catch {
-		return null;
-	}
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function schemaErrorMessage(err) {
-	return err instanceof Error ? err.message : String(err);
-}
-//#endregion
-//#region src/skill-checks/tests-pack.ts
-async function parseTestsPack(input) {
-	return Effect.runPromise(parseTestsPackEffect(input).pipe(Effect.provide(NodeServicesLive)));
-}
-function parseTestsPackEffect(input) {
-	return Effect.gen(function* () {
-		const fs = yield* FileSystem;
-		const yaml = yield* YamlParser;
-		const files = yield* expandGlobEffect(input.testsGlob, input.baseDir);
-		const tests = [];
-		const parseErrors = [];
-		for (const file of files) {
-			const parsedFile = yield* Effect.either(Effect.gen(function* () {
-				const raw = yield* fs.readText(file);
-				const document = decodeTestPackDocument(yield* yaml.parse(raw));
-				if (document.parseError) return { error: document.parseError };
-				return { cases: document.cases.map((c) => parseCase(file, c)) };
-			}));
-			if (parsedFile._tag === "Left") parseErrors.push({
-				filePath: file,
-				error: String(parsedFile.left)
-			});
-			else if ("error" in parsedFile.right && parsedFile.right.error !== void 0) parseErrors.push({
-				filePath: file,
-				error: parsedFile.right.error
-			});
-			else tests.push(...parsedFile.right.cases);
-		}
-		const verifierScripts = uniq(tests.flatMap((t) => {
-			const fixtureRoot = typeof t.vars.fixture === "string" ? isAbsolute(t.vars.fixture) ? t.vars.fixture : resolve(input.baseDir, t.vars.fixture) : input.baseDir;
-			return collectVerifierScripts(t.vars).map((p) => absolveScript(p, fixtureRoot));
-		}));
-		const missingVerifierScripts = [];
-		const nonExecutableVerifierScripts = [];
-		for (const s of verifierScripts) if (!(yield* pathExists(s))) missingVerifierScripts.push(s);
-		else if (!(yield* pathExecutable(s))) nonExecutableVerifierScripts.push(s);
-		const fixturePaths = uniq(tests.map((t) => typeof t.vars.fixture === "string" ? t.vars.fixture : null).filter((p) => p !== null).map((p) => isAbsolute(p) ? p : resolve(input.baseDir, p)));
-		const missingFixturePaths = [];
-		for (const p of fixturePaths) if (!(yield* pathExists(p))) missingFixturePaths.push(p);
-		return {
-			matchedFiles: files,
-			tests,
-			parseErrors,
-			verifierScripts,
-			missingVerifierScripts,
-			nonExecutableVerifierScripts,
-			fixturePaths,
-			missingFixturePaths,
-			unresolvedEffectTypes: uniq(tests.flatMap((t) => t.effectTypes)).filter((e) => !input.knownEffectTypes.has(e))
-		};
-	});
-}
-function parseCase(filePath, input) {
-	const decoded = decodeStaticTestCase(input);
-	const c = decoded.caseRecord;
-	const vars = decoded.vars;
-	const description = typeof c.description === "string" ? c.description : void 0;
-	const parsed = parseRuntimeTestFields(vars);
-	const effectTypes = uniq([
-		...parsed.preconditions,
-		...parsed.should,
-		...parsed.should_not
-	].map((entry) => entry.type));
-	const entryErrors = [...decoded.entryErrors, ...parsed.errors];
-	const isNegative = vars.kind === "negative" || Array.isArray(vars.should_not) && vars.should_not.length > 0 && (!Array.isArray(vars.should) || vars.should.length === 0);
-	return {
-		filePath,
-		description,
-		vars,
-		effectTypes,
-		hasFixture: typeof vars.fixture === "string" || vars.fixtureless === true,
-		isNegative,
-		hasPrecondition: Array.isArray(vars.preconditions) && vars.preconditions.length > 0,
-		hasTokenBudget: declaresTokenBudget(c.assert),
-		isDraft: vars.draft === true || typeof c.metadata === "object" && c.metadata !== null && c.metadata.draft === true,
-		entryErrors
-	};
-}
-function declaresTokenBudget(assertions) {
-	if (!Array.isArray(assertions)) return false;
-	return assertions.some((assertion) => {
-		if (!assertion || typeof assertion !== "object" || Array.isArray(assertion)) return false;
-		const record = assertion;
-		if (record.metric === "skill.budget") return true;
-		return (record.config && typeof record.config === "object" && !Array.isArray(record.config) ? record.config : {}).metric === "skill.budget";
-	});
-}
-function collectVerifierScripts(vars) {
-	const out = [];
-	const parsed = {
-		preconditions: parseAssertionEntries(vars.preconditions, "preconditions", { allowMissing: true }),
-		should: parseAssertionEntries(vars.should, "should", { allowMissing: true }),
-		should_not: parseAssertionEntries(vars.should_not, "should_not", { allowMissing: true })
-	};
-	for (const entries of Object.values(parsed)) for (const entry of entries.entries) {
-		if (!isVerifierEntry(entry)) continue;
-		if (entry.args && typeof entry.args === "object" && typeof entry.args.run === "string") out.push(entry.args.run);
-	}
-	return out;
-}
-function isVerifierEntry(entry) {
-	return entry.type === "verifier.succeeds" || entry.type === "verifier.fails";
-}
-function absolveScript(scriptPath, fixtureRoot) {
-	if (isAbsolute(scriptPath)) return scriptPath;
-	return resolve(fixtureRoot, scriptPath);
-}
-function uniq(xs) {
-	return [...new Set(xs)];
-}
-/**
-* Tiny glob expander. Handles literal paths, `**\/*.yaml`, and a single `*`
-* segment. Sufficient for Agent Skill Evals conventions.
-*/
-function expandGlobEffect(pattern, baseDir) {
-	return Effect.gen(function* () {
-		const fs = yield* FileSystem;
-		const abs = isAbsolute(pattern) ? pattern : resolve(baseDir, pattern);
-		const absStat = yield* fs.stat(abs).pipe(Effect.either);
-		if (absStat._tag === "Right" && absStat.right.isFile()) return [abs];
-		if (absStat._tag === "Right" && absStat.right.isDirectory()) return yield* listYamlEffect(abs);
-		const idx = abs.search(/\*\*?|\*/);
-		if (idx < 0) return [];
-		const root = abs.slice(0, idx).replace(/\/$/, "") || "/";
-		const tail = abs.slice(idx);
-		const matches = [];
-		yield* walkEffect(root, (p) => Effect.sync(() => {
-			if (matchesGlob(p, root, tail)) matches.push(p);
-		}));
-		return matches;
-	});
-}
-function listYamlEffect(dir) {
-	return Effect.gen(function* () {
-		const out = [];
-		yield* walkEffect(dir, (p) => Effect.sync(() => {
-			if (p.endsWith(".yaml") || p.endsWith(".yml")) out.push(p);
-		}));
-		return out;
-	});
-}
-function walkEffect(dir, visit) {
-	return Effect.gen(function* () {
-		const entries = yield* (yield* FileSystem).readDirectory(dir).pipe(Effect.catchAll(() => Effect.succeed([])));
-		for (const e of entries) {
-			const p = join(dir, e.name);
-			if (e.isDirectory()) {
-				if (e.name === "node_modules" || e.name === ".git") continue;
-				yield* walkEffect(p, visit);
-			} else if (e.isFile()) yield* visit(p);
-		}
-	});
-}
-function matchesGlob(p, root, tail) {
-	if (!p.startsWith(root)) return false;
-	const rel = p.slice(root.length).replace(/^\//, "");
-	return new RegExp("^" + tail.replace(/^\//, "").replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*\//g, "(?:.*/)?").replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*") + "$").test(rel);
-}
-//#endregion
-//#region src/skill-checks/index.ts
-const StaticProviderConfigSchema = Schema.Struct({ baseDir: Schema.optional(Schema.String) });
-var AgentSkillEvalsStaticProvider = class {
-	config;
-	configError;
-	id;
-	constructor(options = {}) {
-		const config = decodeStaticProviderConfig(options.config ?? {});
-		if ("error" in config) {
-			this.config = {};
-			this.configError = config.error;
-		} else this.config = config;
-		const label = options.id ?? "agent-skill-evals-static";
-		this.id = () => label;
-	}
-	async callApi(_prompt, context = {}) {
-		return Effect.runPromise(this.callApiEffect(_prompt, context).pipe(Effect.provide(NodeServicesLive)));
-	}
-	callApiEffect(_prompt, context = {}) {
-		const self = this;
-		return Effect.gen(function* () {
-			if (self.configError) return {
-				output: "",
-				error: self.configError
-			};
-			const vars = context.vars ?? context.test?.vars ?? {};
-			const cwd = yield* (yield* Environment).cwd;
-			const baseDir = self.config.baseDir ?? cwd;
-			const knownTypes = new Set(RUNTIME_CHECK_TYPES);
-			const skillPath = stringVar(vars, "skillPath");
-			const testsGlob = stringVar(vars, "testsGlob");
-			const warnings = [];
-			if (!skillPath) return {
-				output: "",
-				error: "skill checks: vars.skillPath is required (example: skillPath: ./skills/bugfix-workflow)"
-			};
-			if (!testsGlob) return {
-				output: "",
-				error: "skill checks: vars.testsGlob is required (example: testsGlob: ./tests/bugfix-workflow.yaml)"
-			};
-			let skill = null;
-			const skillAbs = isAbsolute(skillPath) ? skillPath : resolve(baseDir, skillPath);
-			const skillMd = yield* ensureSkillMdEffect(skillAbs);
-			if (skillMd === null) return {
-				output: "",
-				error: `skill checks: SKILL.md not found at ${skillAbs}`
-			};
-			const parsedSkill = yield* Effect.either(parseSkillMdEffect(skillMd));
-			if (Either.isLeft(parsedSkill)) return {
-				output: "",
-				error: `skill checks: failed to parse SKILL.md at ${skillMd}: ${parsedSkill.left instanceof Error ? parsedSkill.left.message : String(parsedSkill.left)}`
-			};
-			skill = parsedSkill.right;
-			let tests = null;
-			tests = yield* parseTestsPackEffect({
-				testsGlob,
-				baseDir,
-				knownEffectTypes: knownTypes
-			});
-			const missingFiles = [];
-			if (skill) for (const ref of skill.missingReferences) missingFiles.push(`${skill.skillDir}/${ref}`);
-			if (tests) {
-				missingFiles.push(...tests.missingVerifierScripts);
-				missingFiles.push(...tests.missingFixturePaths);
-			}
-			const metadata = {
-				skill,
-				tests,
-				missingFiles,
-				unresolvedEffectTypes: tests?.unresolvedEffectTypes ?? [],
-				warnings
-			};
-			return {
-				output: summarise(metadata),
-				metadata
-			};
-		});
-	}
-};
-function decodeStaticProviderConfig(input) {
-	const decoded = Schema.decodeUnknownEither(StaticProviderConfigSchema, { errors: "all" })(input ?? {});
-	if (Either.isRight(decoded)) return decoded.right;
-	return { error: `skill checks: invalid config: ${ParseResult.TreeFormatter.formatErrorSync(decoded.left)}` };
-}
-function stringVar(vars, key) {
-	const value = vars[key];
-	return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function ensureSkillMdEffect(skillPath) {
-	return Effect.gen(function* () {
-		const fs = yield* FileSystem;
-		const statResult = yield* fs.stat(skillPath).pipe(Effect.either);
-		if (Either.isRight(statResult)) {
-			const s = statResult.right;
-			if (s.isFile()) return skillPath;
-			if (s.isDirectory()) {
-				const candidate = join(skillPath, "SKILL.md");
-				const cs = yield* fs.stat(candidate).pipe(Effect.catchAll(() => Effect.succeed(null)));
-				return cs && cs.isFile() ? candidate : null;
-			}
-			return null;
-		}
-		return null;
-	});
-}
-function summarise(m) {
-	const lines = ["Agent Skill Evals skill check input loaded:"];
-	if (m.skill) lines.push(`- skill: ${m.skill.frontmatter.name ?? "?"} (${m.skill.skillMdPath})`);
-	if (m.tests) lines.push(`- tests: ${m.tests.tests.length} case(s) from ${m.tests.matchedFiles.length} file(s)`);
-	if (m.missingFiles.length) lines.push(`- missing files: ${m.missingFiles.length}`);
-	if (m.unresolvedEffectTypes.length) lines.push(`- unresolved effect types: ${m.unresolvedEffectTypes.length}`);
-	lines.push(m.warnings.length ? `- warnings: ${m.warnings.join("; ")}` : "- warnings: none");
-	return lines.join("\n");
-}
-//#endregion
-export { AgentSkillEvalsStaticProvider, AgentSkillEvalsStaticProvider as default, parseSkillMd, parseTestsPack };
-
-//# sourceMappingURL=index.mjs.map