eve 0.5.4 → 0.6.0-beta.3

package/dist/src/discover/named-source-directory.d.ts

@@ -0,0 +1,97 @@
+import type { MarkdownSourceRef, ModuleSourceRef } from "#shared/source-ref.js";
+import { type DiscoverDiagnostic } from "#discover/diagnostics.js";
+import type { ProjectSource, ProjectSourceEntry } from "#discover/project-source.js";
+/**
+ * Shared input shape for {@link discoverNamedSourceDirectory}.
+ *
+ * The walker collects authored `.ts/.cts/.mts/.js/.cjs/.mjs` modules under
+ * one named root (e.g. `tools/`, `channels/`, `hooks/`) and — when
+ * `allowMarkdown` is set — also `.md` files lowered through
+ * `markdownLowerer` (e.g. `schedules/`). The walker emits a
+ * `DISCOVER_SLOT_COLLISION` when a slot has both a markdown and module
+ * file of the same base name.
+ */
+interface DiscoverNamedSourceDirectoryBaseInput {
+    /**
+     * Top-level directory name relative to `rootPath`
+     * (eg. `"tools"`, `"channels"`, `"hooks"`).
+     */
+    directoryName: string;
+    /**
+     * Diagnostic code emitted when `directoryName` exists but is not a
+     * directory.
+     */
+    invalidDirectoryCode: string;
+    /**
+     * Diagnostic message emitted when `directoryName` exists but is not a
+     * directory.
+     */
+    invalidDirectoryMessage: string;
+    rootEntries: readonly ProjectSourceEntry[];
+    rootPath: string;
+    source: ProjectSource;
+    /**
+     * Whether to descend into subdirectories. When `false`, only leaf files
+     * directly inside `directoryName` are considered.
+     */
+    recursive: boolean;
+    /**
+     * Validates each path segment encountered during the walk. Called for
+     * every leaf slot name and, when `recursive`, every subdirectory name.
+     * Failed segments produce a diagnostic and the candidate is dropped.
+     */
+    validateSegment?: (segment: string, sourcePath: string) => DiscoverDiagnostic | null;
+    /**
+     * When set, emit this diagnostic for any leaf file that is neither a
+     * supported authored module nor (when allowed) a markdown file. When
+     * unset, unrecognized leaf files are silently ignored — used by
+     * `tools/`, `channels/`, and `hooks/` so authors can drop incidental
+     * files into those directories without build errors.
+     */
+    unsupportedFileCode?: string;
+    unsupportedFileMessage?: (sourcePath: string, directoryName: string) => string;
+    /**
+     * When set, emit this diagnostic for any directory entry that is neither
+     * a regular file nor a directory (sockets, FIFOs, etc.). Pairs with
+     * `unsupportedFileCode` for callers that want strict leaf checking.
+     */
+    unsupportedEntryCode?: string;
+    unsupportedEntryMessage?: (sourcePath: string, directoryName: string) => string;
+}
+/**
+ * Module-only walker input. Markdown leaves are not collected.
+ */
+export interface DiscoverNamedSourceDirectoryModuleInput extends DiscoverNamedSourceDirectoryBaseInput {
+    allowMarkdown?: false;
+}
+/**
+ * Module-or-markdown walker input. Markdown leaves are lowered through
+ * the supplied `markdownLowerer`.
+ */
+export interface DiscoverNamedSourceDirectoryWithMarkdownInput<TDefinition> extends DiscoverNamedSourceDirectoryBaseInput {
+    allowMarkdown: true;
+    markdownLowerer: (markdown: string, input: {
+        name: string;
+    }) => TDefinition;
+}
+/**
+ * Discovers one named directory of authored sources, supporting flat or
+ * recursive walks and (optionally) markdown leaves alongside modules.
+ *
+ * Used by the `tools/` (flat), `channels/` (recursive), `hooks/`
+ * (recursive), `lib/` (recursive), and `schedules/` (recursive,
+ * markdown-or-module) slots.
+ *
+ * Returned `sources` preserve depth-first walk order: subdirectories are
+ * traversed before leaf files at each level, and entries are alphabetically
+ * sorted within each level.
+ */
+export declare function discoverNamedSourceDirectory(input: DiscoverNamedSourceDirectoryModuleInput): Promise<{
+    diagnostics: DiscoverDiagnostic[];
+    sources: ModuleSourceRef[];
+}>;
+export declare function discoverNamedSourceDirectory<TDefinition>(input: DiscoverNamedSourceDirectoryWithMarkdownInput<TDefinition>): Promise<{
+    diagnostics: DiscoverDiagnostic[];
+    sources: (MarkdownSourceRef<TDefinition> | ModuleSourceRef)[];
+}>;
+export {};

package/dist/src/discover/named-source-directory.js

@@ -0,0 +1 @@
+import{join}from"node:path";import{createDiscoverErrorDiagnostic}from"#discover/diagnostics.js";import{getDirectoryEntryType,getSupportedModuleBaseName,normalizeLogicalPath}from"#discover/filesystem.js";import{createModuleSourceRef}from"#discover/manifest.js";import{createModuleSlotCollisionDiagnostic,createSlotCollisionDiagnostic,readSortedDirectoryEntries}from"#discover/grammar.js";import{collectNamedSlotCandidates}from"#discover/slots.js";import{discoverMarkdownSource}from"#discover/markdown.js";async function discoverNamedSourceDirectory(n){let r=join(n.rootPath,n.directoryName),i=n.rootEntries.find(e=>e.name===n.directoryName);if(i===void 0)return{diagnostics:[],sources:[]};if(!i.isDirectory())return{diagnostics:[createDiscoverErrorDiagnostic({code:n.invalidDirectoryCode,message:n.invalidDirectoryMessage,sourcePath:r})],sources:[]};let a=[],o=[];return await walkNamedSourceDirectory({allowMarkdown:n.allowMarkdown===!0,diagnostics:a,markdownLowerer:n.allowMarkdown===!0?n.markdownLowerer:void 0,projectSource:n.source,recursive:n.recursive,relativeDirectory:n.directoryName,rootDirectoryPath:r,sources:o,subdirectoryRelative:``,unsupportedEntryCode:n.unsupportedEntryCode,unsupportedEntryMessage:n.unsupportedEntryMessage,unsupportedFileCode:n.unsupportedFileCode,unsupportedFileMessage:n.unsupportedFileMessage,validateSegment:n.validateSegment}),{diagnostics:a,sources:o}}async function walkNamedSourceDirectory(t){let n=t.subdirectoryRelative===``?t.rootDirectoryPath:join(t.rootDirectoryPath,t.subdirectoryRelative),r=await readSortedDirectoryEntries(t.projectSource,n);t.recursive&&await walkSubdirectories(t,r,n),(t.unsupportedFileCode!==void 0||t.unsupportedEntryCode!==void 0)&&emitUnsupportedLeafDiagnostics(t,r,n),await collectLeafSources(t,r,n)}async function walkSubdirectories(t,n,r){for(let i of n){if(!i.isDirectory())continue;let n=join(r,i.name);if(t.validateSegment!==void 0){let e=t.validateSegment(i.name,n);if(e!==null){t.diagnostics.push(e);continue}}await walkNamedSourceDirectory({allowMarkdown:t.allowMarkdown,diagnostics:t.diagnostics,markdownLowerer:t.markdownLowerer,projectSource:t.projectSource,recursive:t.recursive,relativeDirectory:t.relativeDirectory,rootDirectoryPath:t.rootDirectoryPath,sources:t.sources,subdirectoryRelative:t.subdirectoryRelative===``?i.name:join(t.subdirectoryRelative,i.name),unsupportedEntryCode:t.unsupportedEntryCode,unsupportedEntryMessage:t.unsupportedEntryMessage,unsupportedFileCode:t.unsupportedFileCode,unsupportedFileMessage:t.unsupportedFileMessage,validateSegment:t.validateSegment})}}function emitUnsupportedLeafDiagnostics(i,a,o){for(let s of a){let a=getDirectoryEntryType(s),c=join(o,s.name);if(a===`directory`)continue;if(a===`other`){i.unsupportedEntryCode!==void 0&&i.diagnostics.push(createDiscoverErrorDiagnostic({code:i.unsupportedEntryCode,message:i.unsupportedEntryMessage?.(c,i.relativeDirectory)??`Expected "${c}" to be a regular file or directory within "${i.relativeDirectory}/".`,sourcePath:c}));continue}if(i.unsupportedFileCode===void 0)continue;let l=getSupportedModuleBaseName(s.name)!==null,u=i.allowMarkdown&&s.name.endsWith(`.md`);l||u||i.diagnostics.push(createDiscoverErrorDiagnostic({code:i.unsupportedFileCode,message:i.unsupportedFileMessage?.(c,i.relativeDirectory)??`Expected "${c}" to be a supported authored source within "${i.relativeDirectory}/".`,sourcePath:c}))}}async function collectLeafSources(t,n,r){for(let c of collectNamedSlotCandidates(n,{allowMarkdown:t.allowMarkdown,allowModules:!0})){let n=t.subdirectoryRelative===``?c.slotName:join(t.subdirectoryRelative,c.slotName),l=normalizeLogicalPath(join(t.relativeDirectory,n));if(t.validateSegment!==void 0){let n=c.markdownFileName??c.moduleFileNames[0]??c.slotName,i=t.validateSegment(c.slotName,join(r,n));if(i!==null){t.diagnostics.push(i);continue}}if(c.markdownFileName!==void 0&&c.moduleFileNames.length>0){t.diagnostics.push(createSlotCollisionDiagnostic(r,l,[c.markdownFileName,...c.moduleFileNames]));continue}if(c.moduleFileNames.length>1){t.diagnostics.push(createModuleSlotCollisionDiagnostic(r,l,c.moduleFileNames));continue}if(c.markdownFileName!==void 0){let n=t.subdirectoryRelative===``?c.markdownFileName:join(t.subdirectoryRelative,c.markdownFileName),r=normalizeLogicalPath(join(t.relativeDirectory,n));if(t.markdownLowerer===void 0)continue;let a=await discoverMarkdownSource({logicalPath:r,lower:t.markdownLowerer,source:t.projectSource,sourcePath:join(t.rootDirectoryPath,n)});t.sources.push(a);continue}let[d]=c.moduleFileNames;if(d===void 0)continue;let f=t.subdirectoryRelative===``?d:join(t.subdirectoryRelative,d);t.sources.push(createModuleSourceRef({logicalPath:normalizeLogicalPath(join(t.relativeDirectory,f))}))}}export{discoverNamedSourceDirectory};

package/dist/src/discover/project-source.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Minimum directory-entry shape returned by a {@link ProjectSource}.
+ *
+ * Intentionally matches the subset of `node:fs` `Dirent` methods discovery
+ * actually reads: `name` and the structural type predicates. The matching
+ * shape lets {@link DiskProjectSource} return real `Dirent<string>` values
+ * without an adapter wrapper, while {@link MemoryProjectSource} can return
+ * lightweight plain objects.
+ */
+export interface ProjectSourceEntry {
+    readonly name: string;
+    isDirectory(): boolean;
+    isFile(): boolean;
+}
+/**
+ * Result of a filesystem-style stat against a {@link ProjectSource}.
+ *
+ * - `directory` / `file`: the path resolves to one of those kinds.
+ * - `missing`: the path does not exist in the source.
+ * - `other`: the path exists but is neither a directory nor a regular file
+ *   (symlink, socket, device). Discovery treats this identically to
+ *   `missing` in most places but keeps the distinction for diagnostics.
+ */
+export type ProjectSourceEntryKind = "directory" | "file" | "missing" | "other";
+/**
+ * Abstraction over the filesystem root discovery reads from.
+ *
+ * Every read performed by `src/discover/**` goes through a `ProjectSource`
+ * rather than `node:fs` directly. Production callers use
+ * {@link createDiskProjectSource} — a one-line wrapper around `node:fs` that
+ * preserves existing behaviour. Tests can swap in
+ * {@link createMemoryProjectSource} to run discovery against an in-memory
+ * tree without touching disk, `mkdtemp`, or any fixture copying.
+ *
+ * The interface is intentionally small: discovery needs to read directory
+ * entries, read UTF-8 text files, and classify paths by kind. Nothing more.
+ */
+export interface ProjectSource {
+    /**
+     * Diagnostic label for this source (e.g. `"disk"` or `"memory"`).
+     * Used only for logs and error messages.
+     */
+    readonly kind: "disk" | "memory";
+    /**
+     * Returns the entries of `directoryPath` without any intrinsic ordering.
+     * Callers that require stable ordering should sort explicitly.
+     *
+     * Throws when the path does not resolve to a directory — callers that
+     * want "missing is OK" should stat first.
+     */
+    readDirectory(directoryPath: string): Promise<readonly ProjectSourceEntry[]>;
+    /**
+     * Returns the UTF-8 text content of `filePath`. Throws when the path is
+     * missing or is not a regular file.
+     */
+    readTextFile(filePath: string): Promise<string>;
+    /**
+     * Returns the kind of `targetPath` without throwing for missing paths.
+     */
+    stat(targetPath: string): Promise<ProjectSourceEntryKind>;
+}
+/**
+ * Creates a {@link ProjectSource} backed by the real filesystem. This is the
+ * default for production and for the scenario tier.
+ */
+export declare function createDiskProjectSource(): ProjectSource;
+/**
+ * Declarative descriptor of an in-memory directory tree consumed by
+ * {@link createMemoryProjectSource}.
+ *
+ * Keys are paths; values are UTF-8 text or `{ content }` records.
+ */
+export interface MemoryProjectSourceInput {
+    /**
+     * Optional root hint used only for diagnostics. The source itself accepts
+     * reads against any path — unrelated absolute paths simply resolve as
+     * missing.
+     */
+    readonly rootDir?: string;
+    /**
+     * Map of absolute paths to file content.
+     */
+    readonly files: Readonly<Record<string, string | {
+        readonly content: string;
+    }>>;
+    /**
+     * Optional list of absolute paths that should exist as directories even
+     * though no files live underneath them. Discovery treats these exactly
+     * like real empty folders on disk — they appear in `readDirectory`
+     * listings of their parent and return `"directory"` from `stat`.
+     *
+     * Every parent of every file in {@link files} is already registered as
+     * a directory automatically, so this field is only needed for empty
+     * folders (for example, to assert that an empty `connections/` folder
+     * produces no diagnostics).
+     */
+    readonly directories?: readonly string[];
+}
+/**
+ * Creates a {@link ProjectSource} backed by an in-memory file tree.
+ *
+ * Directories are inferred from the set of file paths: every parent of
+ * every file is treated as a directory, and directory listings return the
+ * immediate children. This matches the shape of real filesystems closely
+ * enough for all discovery code paths.
+ */
+export declare function createMemoryProjectSource(input: MemoryProjectSourceInput): ProjectSource;

package/dist/src/discover/project-source.js

@@ -0,0 +1 @@
+import{posix,sep}from"node:path";import{readFile,readdir,stat}from"node:fs/promises";function createDiskProjectSource(){return{kind:`disk`,async readDirectory(e){return await readdir(e,{withFileTypes:!0})},async readTextFile(e){return await readFile(e,`utf8`)},async stat(e){try{let t=await stat(e);return t.isDirectory()?`directory`:t.isFile()?`file`:`other`}catch{return`missing`}}}}function createMemoryProjectSource(t){let n=new Map,r=new Map;function registerDirectory(e){let t=r.get(e);return t===void 0&&(t=new Map,r.set(e,t)),t}function registerChildOfDirectory(t,n,r){if(registerDirectory(t).get(n)===`file`&&r===`directory`)throw TypeError(`MemoryProjectSource: path "${posix.join(t,n)}" registered as both a file and a directory.`);registerDirectory(t).set(n,r)}for(let[e,r]of Object.entries(t.files)){let t=normalizeToPosix(e),i=typeof r==`string`?r:r.content;n.set(t,i);let a=splitPosixPath(t);if(a.length===0)throw TypeError(`MemoryProjectSource: cannot register root path "${e}" as a file.`);let o=a[a.length-1];if(o===void 0)throw TypeError(`MemoryProjectSource: empty file name in "${e}".`);let s=`/`;for(let e=0;e<a.length-1;e+=1){let t=a[e];t!==void 0&&(registerChildOfDirectory(s,t,`directory`),s=s===`/`?`/${t}`:`${s}/${t}`)}registerChildOfDirectory(s,o,`file`)}for(let e of t.directories??[]){let t=normalizeToPosix(e),n=splitPosixPath(t);registerDirectory(t);let r=`/`;for(let e=0;e<n.length;e+=1){let t=n[e];t!==void 0&&(registerChildOfDirectory(r,t,`directory`),r=r===`/`?`/${t}`:`${r}/${t}`)}}return{kind:`memory`,async readDirectory(e){let n=normalizeToPosix(e),i=r.get(n);if(i===void 0)throw Error(`MemoryProjectSource: directory "${e}" does not exist${t.rootDir===void 0?``:` (root: ${t.rootDir})`}.`);return[...i.entries()].map(([e,t])=>createMemoryEntry(e,t))},async readTextFile(e){let r=normalizeToPosix(e),i=n.get(r);if(i===void 0)throw Error(`MemoryProjectSource: file "${e}" does not exist${t.rootDir===void 0?``:` (root: ${t.rootDir})`}.`);return i},async stat(e){let t=normalizeToPosix(e);return n.has(t)?`file`:r.has(t)?`directory`:`missing`}}}function createMemoryEntry(e,t){return{name:e,isDirectory(){return t===`directory`},isFile(){return t===`file`}}}function normalizeToPosix(n){let r=sep===`/`?n:n.replaceAll(sep,`/`);if(r.length===0)return`/`;let i=r.replace(/^[A-Za-z]:/,``),a=i.startsWith(`/`)?i:`/${i}`;return posix.normalize(a).replace(/\/+$/,``)||`/`}function splitPosixPath(e){return e.split(`/`).filter(e=>e.length>0)}export{createDiskProjectSource,createMemoryProjectSource};

package/dist/src/discover/project.d.ts

@@ -0,0 +1,33 @@
+import { type DiscoverDiagnostic } from "#discover/diagnostics.js";
+import { type ProjectSource } from "#discover/project-source.js";
+/**
+ * Supported project layouts for filesystem-based agents.
+ */
+export type DiscoveryProjectLayout = "flat" | "nested";
+/**
+ * Resolved discovery roots for the current application.
+ */
+export interface ResolvedDiscoveryProject {
+    agentRoot: string;
+    appRoot: string;
+    layout: DiscoveryProjectLayout;
+}
+/**
+ * Error raised when discovery cannot resolve an Eve agent root from a
+ * {@link ProjectSource}.
+ */
+export declare class DiscoveryProjectResolutionError extends Error {
+    readonly diagnostic: DiscoverDiagnostic;
+    constructor(diagnostic: DiscoverDiagnostic);
+}
+/**
+ * Resolves the nearest Eve app root and agent root from an arbitrary
+ * starting path.
+ *
+ * By default the resolver walks the real filesystem. Callers that want to
+ * run discovery against an in-memory tree can pass a {@link ProjectSource}
+ * created via `createMemoryProjectSource(...)`.
+ */
+export declare function resolveDiscoveryProject(startPath?: string, options?: {
+    source?: ProjectSource;
+}): Promise<ResolvedDiscoveryProject>;

package/dist/src/discover/project.js

@@ -0,0 +1 @@
+import{basename,dirname,join,resolve}from"node:path";import{DISCOVER_PROJECT_NOT_FOUND,createDiscoverErrorDiagnostic}from"#discover/diagnostics.js";import{classifyAgentRootEntry,getDirectoryEntryType,isProjectMarkerEntry}from"#discover/filesystem.js";import{createDiskProjectSource}from"#discover/project-source.js";var DiscoveryProjectResolutionError=class extends Error{diagnostic;constructor(e){super(e.message),this.name=`DiscoveryProjectResolutionError`,this.diagnostic=e}};async function resolveDiscoveryProject(e=process.cwd(),n={}){let r=n.source??createDiskProjectSource(),a=await resolveSearchDirectory(r,e),o=a;for(;;){let e=await tryResolveNestedProjectFromAgentDirectory(r,o);if(e!==null)return e;let n=await tryResolveNestedProjectFromAppRoot(r,o);if(n!==null)return n;if(await isFlatAgentRoot(r,o))return{agentRoot:o,appRoot:o,layout:`flat`};let i=dirname(o);if(i===o)break;o=i}throw new DiscoveryProjectResolutionError(createDiscoverErrorDiagnostic({code:DISCOVER_PROJECT_NOT_FOUND,message:`Could not resolve an Eve agent root from "${a}".`,sourcePath:a}))}async function resolveSearchDirectory(e,n){let i=resolve(n);return await e.stat(i)===`directory`?i:dirname(i)}async function tryResolveNestedProjectFromAgentDirectory(n,r){if(basename(r)!==`agent`)return null;let i=dirname(r);return await hasProjectMarkers(n,i)?{agentRoot:r,appRoot:i,layout:`nested`}:null}async function tryResolveNestedProjectFromAppRoot(e,t){if(!await hasProjectMarkers(e,t))return null;let r=join(t,`agent`);return await directoryExists(e,r)?{agentRoot:r,appRoot:t,layout:`nested`}:null}async function isFlatAgentRoot(e,t){let n=await readDirectoryEntryTypes(e,t);return Array.from(n.entries()).some(([e,t])=>{let n=classifyAgentRootEntry(e,t);return n!==`unknown`&&n!==`lib-directory`})}async function hasProjectMarkers(e,t){let n=await readDirectoryEntryTypes(e,t);return Array.from(n.entries()).some(([e,t])=>isProjectMarkerEntry(e,t))}async function readDirectoryEntryTypes(e,t){if(await e.stat(t)!==`directory`)return new Map;let n=await e.readDirectory(t);return new Map(n.map(e=>[e.name,getDirectoryEntryType(e)]))}async function directoryExists(e,t){return await e.stat(t)===`directory`}export{DiscoveryProjectResolutionError,resolveDiscoveryProject};

package/dist/src/discover/sandbox.d.ts

@@ -0,0 +1,37 @@
+import { type DiscoverDiagnostic } from "#discover/diagnostics.js";
+import { type SandboxSourceRef, type SandboxWorkspaceFolderSourceRef } from "#discover/manifest.js";
+import type { ProjectSource, ProjectSourceEntry } from "#discover/project-source.js";
+/**
+ * Discovery diagnostic emitted when the `sandbox/` folder contains an
+ * authored `workspace/skills/` subtree, which is reserved for the
+ * framework's skill discovery.
+ */
+export declare const DISCOVER_SANDBOX_WORKSPACE_SKILLS_RESERVED = "discover/sandbox-workspace-skills-reserved";
+/**
+ * Discovery diagnostic emitted when the `sandbox/` folder exists but
+ * contains neither a `sandbox.<ext>` module nor a `workspace/`
+ * subdirectory. The folder is inert and almost certainly a typo.
+ */
+export declare const DISCOVER_SANDBOX_FOLDER_EMPTY = "discover/sandbox-folder-empty";
+/**
+ * Result of discovering the authored sandbox from a single agent root.
+ */
+interface DiscoverSandboxSourceResult {
+    diagnostics: DiscoverDiagnostic[];
+    sandbox: SandboxSourceRef | null;
+    sandboxWorkspace: SandboxWorkspaceFolderSourceRef | null;
+}
+/**
+ * Discovers the single authored sandbox.
+ *
+ * Looks for `agent/sandbox/` first; the folder owns the sandbox when
+ * it exists (and may carry an authored `workspace/` subtree). If no
+ * folder is present, falls back to a top-level `agent/sandbox.<ext>`
+ * shorthand for agents that don't need a workspace.
+ */
+export declare function discoverSandboxSource(input: {
+    rootEntries: readonly ProjectSourceEntry[];
+    rootPath: string;
+    source: ProjectSource;
+}): Promise<DiscoverSandboxSourceResult>;
+export {};

package/dist/src/discover/sandbox.js

@@ -0,0 +1 @@
+import{join}from"node:path";import{createDiscoverErrorDiagnostic}from"#discover/diagnostics.js";import{normalizeLogicalPath}from"#discover/filesystem.js";import{createModuleSourceRef,createPathDerivedSourceId}from"#discover/manifest.js";import{DISCOVER_MODULE_SLOT_COLLISION,DISCOVER_SANDBOX_DIRECTORY_INVALID,readSortedDirectoryEntries}from"#discover/grammar.js";import{collectFlatSlotCandidates,collectNamedSlotCandidates}from"#discover/slots.js";const SANDBOX_DIRECTORY_NAME=`sandbox`,SANDBOX_WORKSPACE_DIRECTORY_NAME=`workspace`,SANDBOX_DEFINITION_BASE_NAME=`sandbox`,DISCOVER_SANDBOX_WORKSPACE_SKILLS_RESERVED=`discover/sandbox-workspace-skills-reserved`,DISCOVER_SANDBOX_FOLDER_EMPTY=`discover/sandbox-folder-empty`;async function discoverSandboxSource(o){let s=[],c=o.rootEntries.find(e=>e.name===SANDBOX_DIRECTORY_NAME);if(c===void 0)return discoverRootSandboxModule({diagnostics:s,rootEntries:o.rootEntries,rootPath:o.rootPath});let l=join(o.rootPath,SANDBOX_DIRECTORY_NAME);if(!c.isDirectory())return s.push(createDiscoverErrorDiagnostic({code:DISCOVER_SANDBOX_DIRECTORY_INVALID,message:`Expected "${l}" to be the sandbox folder.`,sourcePath:l})),{diagnostics:s,sandbox:null,sandboxWorkspace:null};let u=await readSortedDirectoryEntries(o.source,l),d=collectFolderSandboxModuleCandidates(u),f=u.find(e=>e.name===SANDBOX_WORKSPACE_DIRECTORY_NAME&&e.isDirectory());if(d.length>1)return s.push(createDiscoverErrorDiagnostic({code:DISCOVER_MODULE_SLOT_COLLISION,message:`Found multiple sandbox definition modules inside "${normalizeLogicalPath(SANDBOX_DIRECTORY_NAME)}": `+d.map(e=>`"${e}"`).join(`, `),sourcePath:l})),{diagnostics:s,sandbox:null,sandboxWorkspace:null};let[p]=d,m=p!==void 0,h=f!==void 0;if(!m&&!h)return s.push(createDiscoverErrorDiagnostic({code:DISCOVER_SANDBOX_FOLDER_EMPTY,message:`Sandbox folder "sandbox/" contains neither a "sandbox.<ext>" definition nor a "workspace/" subdirectory. Add one or the other, or remove the folder.`,sourcePath:l})),{diagnostics:s,sandbox:null,sandboxWorkspace:null};let g=null;m&&(g=createModuleSourceRef({logicalPath:join(SANDBOX_DIRECTORY_NAME,p)}));let _=null;if(h){let t=join(l,SANDBOX_WORKSPACE_DIRECTORY_NAME),r=normalizeLogicalPath(join(SANDBOX_DIRECTORY_NAME,SANDBOX_WORKSPACE_DIRECTORY_NAME)),a=await checkWorkspaceSkillsReservation(o.source,t);a===null?_={logicalPath:r,rootEntries:await collectWorkspaceRootEntries(o.source,t),sourceId:createPathDerivedSourceId(r),sourcePath:t}:s.push(a)}return{diagnostics:s,sandbox:g,sandboxWorkspace:_}}function discoverRootSandboxModule(e){let n=collectFlatSlotCandidates(e.rootEntries,{moduleBaseName:SANDBOX_DEFINITION_BASE_NAME});if(n.moduleFileNames.length>1)return e.diagnostics.push(createDiscoverErrorDiagnostic({code:DISCOVER_MODULE_SLOT_COLLISION,message:`Found multiple top-level sandbox definition modules: `+n.moduleFileNames.map(e=>`"${e}"`).join(`, `),sourcePath:e.rootPath})),{diagnostics:e.diagnostics,sandbox:null,sandboxWorkspace:null};let[i]=n.moduleFileNames;return i===void 0?{diagnostics:e.diagnostics,sandbox:null,sandboxWorkspace:null}:{diagnostics:e.diagnostics,sandbox:createModuleSourceRef({logicalPath:i}),sandboxWorkspace:null}}function collectFolderSandboxModuleCandidates(e){let t=e.filter(e=>e.isFile()),n=[];for(let e of collectNamedSlotCandidates(t,{allowMarkdown:!1,allowModules:!0}))e.slotName===SANDBOX_DEFINITION_BASE_NAME&&n.push(...e.moduleFileNames);return n}async function collectWorkspaceRootEntries(e,t){let n=await readSortedDirectoryEntries(e,t),r=[];for(let e of n){if(e.isDirectory()){r.push(`${e.name}/`);continue}e.isFile()&&r.push(e.name)}return r}async function checkWorkspaceSkillsReservation(n,r){return(await readSortedDirectoryEntries(n,r)).find(e=>e.name===`skills`)===void 0?null:createDiscoverErrorDiagnostic({code:DISCOVER_SANDBOX_WORKSPACE_SKILLS_RESERVED,message:`"sandbox/workspace/skills/" is reserved for the framework skill discovery. Move skill files under "agent/skills/" instead, or rename the subtree.`,sourcePath:join(r,`skills`)})}export{DISCOVER_SANDBOX_FOLDER_EMPTY,DISCOVER_SANDBOX_WORKSPACE_SKILLS_RESERVED,discoverSandboxSource};

package/dist/src/discover/schedules.d.ts

@@ -0,0 +1,38 @@
+import type { DiscoverDiagnostic } from "#discover/diagnostics.js";
+import type { ScheduleSourceRef } from "#discover/manifest.js";
+import type { ProjectSource, ProjectSourceEntry } from "#discover/project-source.js";
+/**
+ * Diagnostic emitted when the authored `schedules/` root exists but is not
+ * a directory.
+ */
+export declare const DISCOVER_SCHEDULES_DIRECTORY_INVALID = "discover/schedules-directory-invalid";
+/**
+ * Diagnostic emitted when discovery finds a file under `schedules/` that
+ * is neither an authored module nor a markdown schedule.
+ */
+export declare const DISCOVER_SCHEDULE_FILE_UNSUPPORTED = "discover/schedule-file-unsupported";
+/**
+ * Input for discovering authored schedules under `schedules/`.
+ */
+interface DiscoverScheduleSourcesInput {
+    agentRoot: string;
+    rootEntries: readonly ProjectSourceEntry[];
+    source: ProjectSource;
+}
+/**
+ * Result of discovering authored schedules under `schedules/`.
+ */
+interface DiscoverScheduleSourcesResult {
+    diagnostics: DiscoverDiagnostic[];
+    schedules: ScheduleSourceRef[];
+}
+/**
+ * Discovers authored schedule sources under `schedules/`. Schedules are
+ * single files: either `<name>.{ts,...}` (with `defineSchedule({...})` as
+ * the default export) or `<name>.md` (with frontmatter declaring `cron`).
+ * Recursive nesting is supported; the schedule name is derived from the
+ * relative path under `schedules/` minus the file extension
+ * (`schedules/billing/invoice-sweep.ts` → `billing/invoice-sweep`).
+ */
+export declare function discoverScheduleSources(input: DiscoverScheduleSourcesInput): Promise<DiscoverScheduleSourcesResult>;
+export {};

package/dist/src/discover/schedules.js

@@ -0,0 +1 @@
+import{join}from"node:path";import{discoverNamedSourceDirectory}from"#discover/grammar.js";import{lowerScheduleMarkdown}from"#internal/helpers/markdown.js";const DISCOVER_SCHEDULES_DIRECTORY_INVALID=`discover/schedules-directory-invalid`,DISCOVER_SCHEDULE_FILE_UNSUPPORTED=`discover/schedule-file-unsupported`;async function discoverScheduleSources(t){let n=await discoverNamedSourceDirectory({allowMarkdown:!0,directoryName:`schedules`,invalidDirectoryCode:DISCOVER_SCHEDULES_DIRECTORY_INVALID,invalidDirectoryMessage:`Expected "${join(t.agentRoot,`schedules`)}" to be a directory of authored schedules.`,markdownLowerer:e=>lowerScheduleMarkdown(e),recursive:!0,rootEntries:t.rootEntries,rootPath:t.agentRoot,source:t.source,unsupportedFileCode:DISCOVER_SCHEDULE_FILE_UNSUPPORTED,unsupportedFileMessage:e=>`Expected "${e}" to be a TypeScript or markdown schedule file within "schedules/".`});return{diagnostics:n.diagnostics,schedules:n.sources}}export{DISCOVER_SCHEDULES_DIRECTORY_INVALID,DISCOVER_SCHEDULE_FILE_UNSUPPORTED,discoverScheduleSources};

package/dist/src/discover/skills.d.ts

@@ -0,0 +1,38 @@
+import { type DiscoverDiagnostic } from "#discover/diagnostics.js";
+import { type SkillSourceRef } from "#discover/manifest.js";
+import { type ProjectSource } from "#discover/project-source.js";
+/**
+ * Diagnostics emitted by skill discovery.
+ */
+export declare const DISCOVER_SKILLS_DIRECTORY_INVALID = "discover/skills-directory-invalid";
+export declare const DISCOVER_SKILL_COLLISION = "discover/skill-collision";
+export declare const DISCOVER_SKILL_ENTRY_NOT_DIRECTORY = "discover/skill-entry-not-directory";
+export declare const DISCOVER_SKILL_FRONTMATTER_INVALID = "discover/skill-frontmatter-invalid";
+export declare const DISCOVER_SKILL_MARKDOWN_MISSING = "discover/skill-markdown-missing";
+/**
+ * Input for discovering authored skills.
+ */
+interface DiscoverSkillsInput {
+    agentRoot: string;
+    /**
+     * Optional {@link ProjectSource} used for all filesystem reads. Defaults to
+     * a disk-backed source so disk callers keep their current behaviour.
+     */
+    source?: ProjectSource;
+    skillsDirectoryPath?: string;
+    skillsLogicalPath?: string;
+}
+/**
+ * Result of discovering authored skills.
+ */
+interface DiscoverSkillsResult {
+    diagnostics: DiscoverDiagnostic[];
+    skills: SkillSourceRef[];
+}
+/**
+ * Discovers authored skills from either flat
+ * `skills/<name>.md|ts|cts|mts|js|cjs|mjs`
+ * entries or Agent Skills packages rooted at `skills/<name>/SKILL.md`.
+ */
+export declare function discoverSkills(input: DiscoverSkillsInput): Promise<DiscoverSkillsResult>;
+export {};

package/dist/src/discover/skills.js

@@ -0,0 +1 @@
+import{join,relative,resolve}from"node:path";import{toErrorMessage}from"#shared/errors.js";import{createDiscoverErrorDiagnostic}from"#discover/diagnostics.js";import{classifySkillPackageEntry,classifySkillsDirectoryEntry,getDirectoryEntryType,getSupportedModuleBaseName,normalizeLogicalPath}from"#discover/filesystem.js";import{createDiskProjectSource}from"#discover/project-source.js";import{createModuleSourceRef,createPathDerivedSourceId,createSkillPackageSourceRef}from"#discover/manifest.js";import{readSortedDirectoryEntries}from"#discover/grammar.js";import{lowerSkillMarkdown}from"#internal/helpers/markdown.js";const DISCOVER_SKILLS_DIRECTORY_INVALID=`discover/skills-directory-invalid`,DISCOVER_SKILL_COLLISION=`discover/skill-collision`,DISCOVER_SKILL_ENTRY_NOT_DIRECTORY=`discover/skill-entry-not-directory`,DISCOVER_SKILL_FRONTMATTER_INVALID=`discover/skill-frontmatter-invalid`,DISCOVER_SKILL_MARKDOWN_MISSING=`discover/skill-markdown-missing`;async function discoverSkills(r){let a=r.source??createDiskProjectSource(),o=resolve(r.agentRoot),c=resolve(r.skillsDirectoryPath??join(o,`skills`)),l=normalizeLogicalPath(r.skillsLogicalPath??relative(o,c)),u=await a.stat(c);if(u===`missing`)return{diagnostics:[],skills:[]};if(u!==`directory`)return{diagnostics:[createDiscoverErrorDiagnostic({code:DISCOVER_SKILLS_DIRECTORY_INVALID,message:`Expected "${c}" to be a directory of authored skills.`,sourcePath:c})],skills:[]};let d=[],f=new Set,p=new Map,m=await readSortedDirectoryEntries(a,c);for(let t of m){let n=await discoverOneSkill({entryName:t.name,entryType:getDirectoryEntryType(t),skillsDirectoryPath:c,skillsLogicalPath:l,source:a});if(d.push(...n.diagnostics),n.skill===null||n.skillId===null||f.has(n.skillId))continue;let r=p.get(n.skillId);if(r!==void 0){d.push(createDiscoverErrorDiagnostic({code:DISCOVER_SKILL_COLLISION,message:`Found conflicting authored skill sources for "${n.skillId}": "${r.logicalPath}" and "${n.logicalPath}".`,sourcePath:join(c,n.skillId)})),f.add(n.skillId),p.delete(n.skillId);continue}p.set(n.skillId,{logicalPath:n.logicalPath,skill:n.skill})}return{diagnostics:d,skills:[...p.values()].map(e=>e.skill)}}async function discoverOneSkill(t){let n=join(t.skillsDirectoryPath,t.entryName);switch(classifySkillsDirectoryEntry(t.entryName,t.entryType)){case`skill-package-directory`:return discoverPackagedSkill({logicalSkillsPath:t.skillsLogicalPath,skillId:t.entryName,skillRootPath:n,source:t.source});case`flat-skill-markdown`:return discoverFlatMarkdownSkill({logicalSkillsPath:t.skillsLogicalPath,skillFileName:t.entryName,skillFilePath:n,source:t.source});case`flat-skill-module`:return discoverFlatModuleSkill({logicalSkillsPath:t.skillsLogicalPath,skillFileName:t.entryName});default:return{diagnostics:[createDiscoverErrorDiagnostic({code:DISCOVER_SKILL_ENTRY_NOT_DIRECTORY,message:`Expected "${n}" to be a skill directory containing SKILL.md or a flat ".md", ".ts", ".cts", ".mts", ".js", ".cjs", or ".mjs" skill file.`,sourcePath:n})],logicalPath:normalizeLogicalPath(join(t.skillsLogicalPath,t.entryName)),skill:null,skillId:null}}}async function discoverPackagedSkill(t){let n=join(t.skillRootPath,`SKILL.md`),r=normalizeLogicalPath(join(t.logicalSkillsPath,t.skillId,`SKILL.md`));if(await t.source.stat(n)!==`file`)return{diagnostics:[createDiscoverErrorDiagnostic({code:DISCOVER_SKILL_MARKDOWN_MISSING,message:`Expected "${n}" to exist for the "${t.skillId}" skill.`,sourcePath:t.skillRootPath})],logicalPath:r,skill:null,skillId:null};let a;try{a=lowerSkillMarkdown(await t.source.readTextFile(n))}catch(e){return{diagnostics:[createDiscoverErrorDiagnostic({code:DISCOVER_SKILL_FRONTMATTER_INVALID,message:formatSkillDiscoveryError(n,e),sourcePath:n})],logicalPath:r,skill:null,skillId:null}}let o=await discoverSkillPackagePaths(t.source,t.skillRootPath),s={description:a.description,logicalPath:r,markdown:a.markdown,name:t.skillId,rootPath:t.skillRootPath,skillFilePath:n,skillId:t.skillId,sourceId:createPathDerivedSourceId(r)};return o.assetsPath!==void 0&&(s.assetsPath=o.assetsPath),a.license!==void 0&&(s.license=a.license),a.metadata!==void 0&&(s.metadata=a.metadata),o.referencesPath!==void 0&&(s.referencesPath=o.referencesPath),o.scriptsPath!==void 0&&(s.scriptsPath=o.scriptsPath),{diagnostics:[],logicalPath:r,skill:createSkillPackageSourceRef(s),skillId:t.skillId}}async function discoverFlatMarkdownSkill(t){let n=stripMarkdownExtension(t.skillFileName),r=normalizeLogicalPath(join(t.logicalSkillsPath,t.skillFileName)),a;try{a=lowerSkillMarkdown(await t.source.readTextFile(t.skillFilePath),{slug:n})}catch(e){return{diagnostics:[createDiscoverErrorDiagnostic({code:DISCOVER_SKILL_FRONTMATTER_INVALID,message:formatSkillDiscoveryError(t.skillFilePath,e),sourcePath:t.skillFilePath})],logicalPath:r,skill:null,skillId:null}}return{diagnostics:[],logicalPath:r,skill:{definition:a,sourceKind:`markdown`,logicalPath:r,sourceId:createPathDerivedSourceId(r)},skillId:n}}async function discoverFlatModuleSkill(t){let n=getSupportedModuleBaseName(t.skillFileName),r=normalizeLogicalPath(join(t.logicalSkillsPath,t.skillFileName));return n===null?{diagnostics:[],logicalPath:r,skill:null,skillId:null}:{diagnostics:[],logicalPath:r,skill:createModuleSourceRef({logicalPath:r}),skillId:n}}async function discoverSkillPackagePaths(t,n){let r=await t.readDirectory(n),i={};for(let t of r)if(t.isDirectory())switch(classifySkillPackageEntry(t.name,getDirectoryEntryType(t))){case`skill-assets-directory`:i.assetsPath=join(n,t.name);break;case`skill-references-directory`:i.referencesPath=join(n,t.name);break;case`skill-scripts-directory`:i.scriptsPath=join(n,t.name);break;default:break}return i}function formatSkillDiscoveryError(e,t){return`Invalid authored skill frontmatter in "${e}": ${toErrorMessage(t)}`}function stripMarkdownExtension(e){return e.endsWith(`.md`)?e.slice(0,-3):e}export{DISCOVER_SKILLS_DIRECTORY_INVALID,DISCOVER_SKILL_COLLISION,DISCOVER_SKILL_ENTRY_NOT_DIRECTORY,DISCOVER_SKILL_FRONTMATTER_INVALID,DISCOVER_SKILL_MARKDOWN_MISSING,discoverSkills};

package/dist/src/discover/slots.d.ts

@@ -0,0 +1,30 @@
+import type { Dirent } from "node:fs";
+/**
+ * Candidate authored sources for one flat slot such as `system` or `agent`.
+ */
+interface FlatSlotCandidates {
+    markdownFileName?: string;
+    moduleFileNames: string[];
+}
+/**
+ * Candidate authored sources for one named directory slot such as
+ * `tools/<name>`.
+ */
+interface NamedSlotCandidates extends FlatSlotCandidates {
+    slotName: string;
+}
+/**
+ * Collects markdown and module candidates for one flat slot in one directory.
+ */
+export declare function collectFlatSlotCandidates(entries: readonly Pick<Dirent<string>, "isFile" | "name">[], input: {
+    markdownFileName?: string;
+    moduleBaseName?: string;
+}): FlatSlotCandidates;
+/**
+ * Groups markdown and module candidates for directory-backed named slots.
+ */
+export declare function collectNamedSlotCandidates(entries: readonly Pick<Dirent<string>, "isFile" | "name">[], input: {
+    allowMarkdown: boolean;
+    allowModules: boolean;
+}): NamedSlotCandidates[];
+export {};

package/dist/src/discover/slots.js

@@ -0,0 +1 @@
+import{getSupportedModuleBaseName}from"#discover/filesystem.js";function collectFlatSlotCandidates(t,n){let r={moduleFileNames:[]};for(let i of t)if(i.isFile()){if(n.markdownFileName!==void 0&&i.name===n.markdownFileName){r.markdownFileName=i.name;continue}n.moduleBaseName!==void 0&&getSupportedModuleBaseName(i.name)===n.moduleBaseName&&r.moduleFileNames.push(i.name)}return r.moduleFileNames.sort((e,t)=>e.localeCompare(t)),r}function collectNamedSlotCandidates(t,n){let r=new Map;for(let i of t){if(!i.isFile())continue;let t=n.allowMarkdown?getMarkdownSlotName(i.name):null,a=n.allowModules?getSupportedModuleBaseName(i.name):null,o=t??a;if(o===null)continue;let s=r.get(o);if(s===void 0&&(s={moduleFileNames:[],slotName:o},r.set(o,s)),t!==null){s.markdownFileName=i.name;continue}a!==null&&s.moduleFileNames.push(i.name)}return[...r.values()].map(e=>(e.moduleFileNames.sort((e,t)=>e.localeCompare(t)),e)).sort((e,t)=>e.slotName.localeCompare(t.slotName))}function getMarkdownSlotName(e){return!e.endsWith(`.md`)||e.length<=3?null:e.slice(0,-3)}export{collectFlatSlotCandidates,collectNamedSlotCandidates};

package/dist/src/evals/cli/eval.d.ts

@@ -0,0 +1,18 @@
+interface EvalCliOptions {
+    suite?: string[];
+    url?: string;
+    timeout?: string;
+    maxConcurrency?: string;
+    json?: boolean;
+    all?: boolean;
+    skipReport?: boolean;
+}
+type EvalCliLogger = {
+    log(message: string): void;
+    error(message: string): void;
+};
+/**
+ * Runs the `eve eval` command with already-parsed Commander options.
+ */
+export declare function runEvalCommand(options: EvalCliOptions, logger: EvalCliLogger): Promise<void>;
+export {};

package/dist/src/evals/cli/eval.js

@@ -0,0 +1 @@
+import{VERCEL_PROTECTION_BYPASS_HEADER}from"#services/dev-client/request-headers.js";import{resolveApplicationRoot}from"#internal/application/paths.js";import{Client}from"#client/client.js";import{getVercelOidcToken}from"#compiled/@vercel/oidc/index.js";import{loadDevelopmentEnvironmentFiles}from"#cli/dev/environment.js";import{startDevelopmentServer}from"#internal/nitro/host.js";import{discoverAndImportSuites}from"#evals/runner/discover.js";import{executeSuite}from"#evals/runner/execute-suite.js";import{ConsoleReporter}from"#evals/runner/reporters/console.js";async function runEvalCommand(e,n){let r=resolveApplicationRoot();loadDevelopmentEnvironmentFiles(r);let s=e.suite,c=await discoverAndImportSuites(r,s);if(c.length===0){s&&s.length>0?n.error(`No suites found matching: ${s.join(`, `)}`):n.error(`No eval suites found. Create suite files under evals/ with the *.eval.ts extension.`),process.exitCode=1;return}let l,u;e.url?u={kind:`remote`,url:e.url}:(l=await startDevelopmentServer(r,{host:`127.0.0.1`,port:0}),u={kind:`local`,url:l.url});let d=createEvalClient(u);try{let t=[];for(let n of c){let i=applyCliOverrides(n,e),a=buildReporters(i,{json:e.json===!0,skipReport:e.skipReport===!0}),o=await executeSuite({suite:i,target:u,reporters:a,appRoot:r,client:d});t.push(o)}e.json&&n.log(JSON.stringify(t,null,2)),t.some(e=>e.errored>0)&&(process.exitCode=1)}finally{l&&await l.close()}process.exit(process.exitCode??0)}function createEvalClient(t){if(t.kind===`local`)return new Client({host:t.url});let r={},i=process.env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim();return i&&(r[VERCEL_PROTECTION_BYPASS_HEADER]=i),new Client({auth:resolveRemoteBearerAuth(),headers:Object.keys(r).length>0?r:void 0,host:t.url})}function resolveRemoteBearerAuth(){let e=process.env.EVE_EVAL_AUTH_TOKEN?.trim();return e?{bearer:e}:{bearer:resolveOidcBearerToken}}async function resolveOidcBearerToken(){try{let e=(await getVercelOidcToken()).trim();if(e.length>0)return e}catch{}return process.env.VERCEL_OIDC_TOKEN?.trim()??``}function applyCliOverrides(e,t){let n=t.maxConcurrency?Number.parseInt(t.maxConcurrency,10):void 0,r=t.timeout?Number.parseInt(t.timeout,10):void 0;if(n===void 0&&r===void 0)return e;let i={...e};return n!==void 0&&(i.maxConcurrency=n),r!==void 0&&(i.timeoutMs=r),i}function buildReporters(e,t){let n=t.json?[]:[new ConsoleReporter];return!t.skipReport&&e.reporters&&n.push(...e.reporters),n}export{runEvalCommand};

package/dist/src/evals/define-eval-suite.d.ts

@@ -0,0 +1,16 @@
+import type { EveEvalSuiteDefinition, EveEvalSuiteInput, EveEvalSuiteInputFields } from "#evals/types.js";
+import type { ExactDefinition } from "#public/definitions/exact.js";
+/**
+ * Defines one Eve eval suite.
+ *
+ * Requires a `model` (used only by model-backed scorers, never the agent
+ * under test) and a `scores` array. Pass either `load` (an async case
+ * loader) or `cases` (a static array), but not both. Suite identity is
+ * derived from the `evals/<path>.eval.ts` file path by the discovery layer,
+ * so authoring `id` or `name` throws.
+ *
+ * Throws on invalid input: missing `model` or `scores`, both or neither of
+ * `load`/`cases`, both `task.prompt` and `task.messages`, a non-positive or
+ * non-integer `maxConcurrency`, or a negative or non-finite `timeoutMs`.
+ */
+export declare function defineEvalSuite<TInput extends EveEvalSuiteInput>(input: ExactDefinition<TInput, EveEvalSuiteInputFields>): EveEvalSuiteDefinition;

package/dist/src/evals/define-eval-suite.js

@@ -0,0 +1 @@
+function defineEvalSuite(e){validateSuiteInput(e);let t=e.load??(()=>Promise.resolve([...e.cases]));return{...e,load:t,_tag:`EveEvalSuite`}}function validateSuiteInput(e){if(`id`in e)throw Error("Eval suite must not specify `id`. Suite identity is derived from the file path under evals/.");if(`name`in e)throw Error("Eval suite must not specify `name`. Suite identity is derived from the file path under evals/.");if(e.model===void 0)throw Error("Eval suite requires a `model`.");if(e.load!==void 0&&e.cases!==void 0)throw Error("Eval suite cannot specify both `load` and `cases`. Use one or the other.");if(e.load===void 0&&e.cases===void 0)throw Error("Eval suite requires either a `load` function or a `cases` array.");if(!Array.isArray(e.scores))throw Error("Eval suite requires a `scores` array.");if(e.task?.prompt!==void 0&&e.task?.messages!==void 0)throw Error("Eval suite task cannot specify both `prompt` and `messages`. Use one or the other.");if(e.maxConcurrency!==void 0&&(e.maxConcurrency<1||!Number.isInteger(e.maxConcurrency)))throw Error("Eval suite `maxConcurrency` must be a positive integer.");if(e.timeoutMs!==void 0&&(e.timeoutMs<0||!Number.isFinite(e.timeoutMs)))throw Error("Eval suite `timeoutMs` must be a non-negative finite number.")}export{defineEvalSuite};

package/dist/src/evals/index.d.ts

@@ -0,0 +1,3 @@
+export { defineEvalSuite } from "#evals/define-eval-suite.js";
+export type { RuntimeIdentity } from "#protocol/message.js";
+export type { EveEvalCase, EveEvalCaseResult, EveEvalDerivedFacts, EveEvalScorer, EveEvalScorerArgs, EveEvalScorerResult, EveEvalSuite, EveEvalSuiteDefinition, EveEvalSuiteInput, EveEvalSuiteResult, EveEvalTarget, EveEvalTask, EveEvalTaskResult, } from "#evals/types.js";

package/dist/src/evals/index.js

@@ -0,0 +1 @@
+import{defineEvalSuite}from"#evals/define-eval-suite.js";export{defineEvalSuite};

package/dist/src/evals/loaders/index.d.ts

@@ -0,0 +1,2 @@
+export { loadJson } from "#evals/loaders/json.js";
+export { loadYaml } from "#evals/loaders/yaml.js";

package/dist/src/evals/loaders/index.js

@@ -0,0 +1 @@
+import{loadJson}from"#evals/loaders/json.js";import{loadYaml}from"#evals/loaders/yaml.js";export{loadJson,loadYaml};

package/dist/src/evals/loaders/json.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Loads and parses a JSON file, returning the parsed value.
+ *
+ * Paths resolve relative to the application root directory (current working
+ * directory). Pass an absolute path to load it directly.
+ *
+ * @example
+ * ```ts
+ * const data = await loadJson("evals/data/cases.json");
+ * ```
+ */
+export declare function loadJson(filePath: string): Promise<unknown>;

package/dist/src/evals/loaders/json.js

@@ -0,0 +1 @@
+import{isAbsolute,resolve}from"node:path";import{readFile}from"node:fs/promises";async function loadJson(e){let t=await readFile(isAbsolute(e)?e:resolve(process.cwd(),e),`utf-8`);return JSON.parse(t)}export{loadJson};

package/dist/src/evals/loaders/yaml.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Loads a YAML file and returns its top-level mapping as a plain object.
+ *
+ * Paths resolve relative to the application root directory (current working
+ * directory). An absolute path loads directly. It parses the file as a YAML
+ * mapping, so the result is always a `Record<string, unknown>` (never a scalar
+ * or array). If the file begins with a `---` frontmatter delimiter, it returns
+ * only the frontmatter mapping and ignores any content after the closing `---`.
+ *
+ * @example
+ * ```ts
+ * const doc = await loadYaml("evals/data/cases.yaml");
+ * const rows = doc.evals;
+ * ```
+ */
+export declare function loadYaml(filePath: string): Promise<Record<string, unknown>>;

package/dist/src/evals/loaders/yaml.js

@@ -0,0 +1 @@
+import{isAbsolute,resolve}from"node:path";import{readFile}from"node:fs/promises";import matter from"#compiled/gray-matter/index.js";async function loadYaml(e){let t=await readFile(isAbsolute(e)?e:resolve(process.cwd(),e),`utf-8`);return matter(t.trimStart().startsWith(`---`)?t:`---\n${t}\n---`).data??{}}export{loadYaml};

package/dist/src/evals/reporters/index.d.ts

@@ -0,0 +1,2 @@
+export { Braintrust, type BraintrustReporterConfig } from "#evals/runner/reporters/braintrust.js";
+export type { EvalReporter } from "#evals/runner/reporters/types.js";

package/dist/src/evals/reporters/index.js

@@ -0,0 +1 @@
+import{Braintrust}from"#evals/runner/reporters/braintrust.js";export{Braintrust};

package/dist/src/evals/runner/artifacts.d.ts

@@ -0,0 +1,11 @@
+import type { EveEvalSuiteResult } from "#evals/types.js";
+/**
+ * Resolves the artifact output directory for one suite run.
+ *
+ * Layout: `.eve/evals/<timestamp>-<suite-id>/`
+ */
+export declare function resolveArtifactDirectory(appRoot: string, suiteId: string): string;
+/**
+ * Writes all artifacts for a completed suite run.
+ */
+export declare function writeArtifacts(artifactDir: string, suiteResult: EveEvalSuiteResult): Promise<void>;

package/dist/src/evals/runner/artifacts.js

@@ -0,0 +1,3 @@
+import{join}from"node:path";import{mkdir,writeFile}from"node:fs/promises";function resolveArtifactDirectory(t,n){return join(t,`.eve`,`evals`,`${new Date().toISOString().replace(/[:.]/g,`-`).slice(0,19)}-${n}`)}async function writeArtifacts(r,i){let a=join(r,`cases`);await mkdir(a,{recursive:!0}),await writeFile(join(r,`summary.json`),JSON.stringify(buildSummaryArtifact(i),null,2));let o=i.cases.map(e=>JSON.stringify(buildCaseResultLine(e))).join(`
+`);await writeFile(join(r,`results.jsonl`),`${o}\n`),await Promise.all(i.cases.map(async t=>{let r=sanitizeFileName(t.case.id);await writeFile(join(a,`${r}.json`),JSON.stringify(buildCaseArtifact(t),null,2));let i=t.result.events.map(e=>JSON.stringify(e)).join(`
+`);await writeFile(join(a,`${r}.events.ndjson`),`${i}\n`)}))}function buildSummaryArtifact(e){return{suite:e.suite,target:e.target,startedAt:e.startedAt,completedAt:e.completedAt,passed:e.passed,errored:e.errored,totalCases:e.cases.length,cases:e.cases.map(e=>({id:e.case.id,status:e.result.status,scores:e.scores.map(e=>({name:e.name,score:e.score})),error:e.error}))}}function buildCaseResultLine(e){return{caseId:e.case.id,status:e.result.status,output:e.result.output,scores:e.scores.map(e=>({name:e.name,score:e.score})),error:e.error}}function buildCaseArtifact(e){return{case:{id:e.case.id,input:e.case.input,expected:e.case.expected,tags:e.case.tags,metadata:e.case.metadata},result:{output:e.result.output,finalMessage:e.result.finalMessage,sessionId:e.result.sessionId,status:e.result.status,derived:e.result.derived},scores:e.scores,error:e.error}}function sanitizeFileName(e){return e.replace(/[^a-zA-Z0-9_-]/g,`_`)}export{resolveArtifactDirectory,writeArtifacts};

package/dist/src/evals/runner/derive-run-facts.d.ts

@@ -0,0 +1,9 @@
+import type { HandleMessageStreamEvent } from "#protocol/message.js";
+import type { EveEvalDerivedFacts } from "#evals/types.js";
+/**
+ * Extracts derived execution facts from a completed run's stream events.
+ *
+ * These facts summarize tool usage, subagent calls, message counts, and
+ * failure information for scoring and reporting.
+ */
+export declare function deriveRunFacts(events: readonly HandleMessageStreamEvent[]): EveEvalDerivedFacts;

package/dist/src/evals/runner/derive-run-facts.js

@@ -0,0 +1 @@
+function deriveRunFacts(e){let t=[],n=[],r=0,i=0,a;for(let o of e)switch(o.type){case`actions.requested`:for(let e of o.data.actions)`toolName`in e&&typeof e.toolName==`string`&&t.push(e.toolName);break;case`subagent.called`:n.push(o.data.name);break;case`subagent.started`:n.push(o.data.subagentName);break;case`message.completed`:o.data.finishReason!==`tool-calls`&&(r+=1);break;case`reasoning.completed`:i+=1;break;case`session.failed`:a=o.data.code;break}return{toolCalls:t,toolCallCount:t.length,subagentCalls:deduplicateStrings(n),subagentCallCount:n.length,messageCount:r,reasoningBlockCount:i,failureCode:a}}function deduplicateStrings(e){return[...new Set(e)]}export{deriveRunFacts};

package/dist/src/evals/runner/discover.d.ts

@@ -0,0 +1,20 @@
+import type { EveEvalSuite } from "#evals/types.js";
+/**
+ * Discovers eval suite files under `<appRoot>/evals/` by recursively
+ * scanning for files matching `*.eval.ts`.
+ *
+ * Returns absolute paths sorted alphabetically by relative path.
+ */
+export declare function discoverSuiteFiles(appRoot: string): Promise<string[]>;
+/**
+ * Imports a discovered suite file and stamps the path-derived id onto
+ * the suite definition.
+ *
+ * The file must `export default` an `EveEvalSuiteDefinition` (produced
+ * by `defineEvalSuite()`).
+ */
+export declare function importSuiteFile(appRoot: string, filePath: string): Promise<EveEvalSuite>;
+/**
+ * Discovers and imports all suite files, optionally filtering by suite ID.
+ */
+export declare function discoverAndImportSuites(appRoot: string, suiteIds?: readonly string[]): Promise<EveEvalSuite[]>;

package/dist/src/evals/runner/discover.js

@@ -0,0 +1 @@
+import{join,relative}from"node:path";import{readdir}from"node:fs/promises";import{loadAuthoredModuleNamespace}from"#internal/authored-module-loader.js";const EVAL_SUITE_GLOB_SUFFIX=`.eval.ts`;async function discoverSuiteFiles(n){let r=join(n,`evals`),i=[];try{await collectSuiteFiles(r,i)}catch(e){if(isNoEntryError(e))return[];throw e}return i.sort((e,n)=>relative(r,e).localeCompare(relative(r,n))),i}function deriveSuiteId(n,r){let a=relative(join(n,`evals`),r).split(/[\\/]/u).join(`/`);return a.endsWith(EVAL_SUITE_GLOB_SUFFIX)?a.slice(0,-8):a}async function importSuiteFile(e,t){let n=(await loadAuthoredModuleNamespace(t)).default;if(!isEveEvalSuiteDefinition(n))throw Error(`Suite file "${t}" does not export a valid EveEvalSuite as its default export. Use defineEvalSuite() to create the suite.`);return{...n,id:deriveSuiteId(e,t)}}async function discoverAndImportSuites(e,t){let n=await discoverSuiteFiles(e);if(n.length===0)return[];let r=[];for(let i of n){let n=await importSuiteFile(e,i);(t===void 0||t.length===0||t.includes(n.id))&&r.push(n)}return r}function isEveEvalSuiteDefinition(e){return typeof e==`object`&&!!e&&`_tag`in e&&e._tag===`EveEvalSuite`}async function collectSuiteFiles(t,r){let a=await readdir(t,{withFileTypes:!0});for(let n of a){let a=join(t,n.name);n.isDirectory()?await collectSuiteFiles(a,r):n.isFile()&&n.name.endsWith(EVAL_SUITE_GLOB_SUFFIX)&&r.push(a)}}function isNoEntryError(e){return typeof e==`object`&&!!e&&`code`in e&&e.code===`ENOENT`}export{discoverAndImportSuites,discoverSuiteFiles,importSuiteFile};