experimental-ash 0.26.0 → 0.28.0

package/dist/src/discover/sandbox.js

@@ -1,220 +1 @@
-import { join } from "node:path";
-import { createDiscoverErrorDiagnostic } from "#discover/diagnostics.js";
-import { normalizeLogicalPath } from "#discover/filesystem.js";
-import { DISCOVER_MODULE_SLOT_COLLISION, DISCOVER_SANDBOX_DIRECTORY_INVALID, readSortedDirectoryEntries, } from "#discover/grammar.js";
-import { createModuleSourceRef, createPathDerivedSourceId, } from "#discover/manifest.js";
-import { collectFlatSlotCandidates, collectNamedSlotCandidates } from "#discover/slots.js";
-/**
- * Agent-root folder name that carries the optional `sandbox.<ext>`
- * override and optional `workspace/` subdirectory.
- */
-const SANDBOX_DIRECTORY_NAME = "sandbox";
-/**
- * Subdirectory inside the sandbox folder that mounts authored files
- * into the live sandbox cwd at session bootstrap.
- */
-const SANDBOX_WORKSPACE_DIRECTORY_NAME = "workspace";
-/**
- * Filename of the sandbox definition module inside the sandbox folder.
- */
-const SANDBOX_DEFINITION_BASE_NAME = "sandbox";
-/**
- * Discovery diagnostic emitted when the `sandbox/` folder contains an
- * authored `workspace/skills/` subtree, which is reserved for the
- * framework's skill discovery.
- */
-export 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 const DISCOVER_SANDBOX_FOLDER_EMPTY = "discover/sandbox-folder-empty";
-/**
- * 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 async function discoverSandboxSource(input) {
-    const diagnostics = [];
-    const directoryEntry = input.rootEntries.find((entry) => entry.name === SANDBOX_DIRECTORY_NAME);
-    if (directoryEntry === undefined) {
-        return discoverRootSandboxModule({
-            diagnostics,
-            rootEntries: input.rootEntries,
-            rootPath: input.rootPath,
-        });
-    }
-    const directoryPath = join(input.rootPath, SANDBOX_DIRECTORY_NAME);
-    if (!directoryEntry.isDirectory()) {
-        diagnostics.push(createDiscoverErrorDiagnostic({
-            code: DISCOVER_SANDBOX_DIRECTORY_INVALID,
-            message: `Expected "${directoryPath}" to be the sandbox folder.`,
-            sourcePath: directoryPath,
-        }));
-        return {
-            diagnostics,
-            sandbox: null,
-            sandboxWorkspace: null,
-        };
-    }
-    const folderEntries = await readSortedDirectoryEntries(input.source, directoryPath);
-    const sandboxModuleCandidates = collectFolderSandboxModuleCandidates(folderEntries);
-    const workspaceFolderEntry = folderEntries.find((folderEntry) => folderEntry.name === SANDBOX_WORKSPACE_DIRECTORY_NAME && folderEntry.isDirectory());
-    if (sandboxModuleCandidates.length > 1) {
-        diagnostics.push(createDiscoverErrorDiagnostic({
-            code: DISCOVER_MODULE_SLOT_COLLISION,
-            message: `Found multiple sandbox definition modules inside "${normalizeLogicalPath(SANDBOX_DIRECTORY_NAME)}": ` +
-                sandboxModuleCandidates.map((name) => `"${name}"`).join(", "),
-            sourcePath: directoryPath,
-        }));
-        return {
-            diagnostics,
-            sandbox: null,
-            sandboxWorkspace: null,
-        };
-    }
-    const [moduleFileName] = sandboxModuleCandidates;
-    const hasModule = moduleFileName !== undefined;
-    const hasWorkspace = workspaceFolderEntry !== undefined;
-    if (!hasModule && !hasWorkspace) {
-        diagnostics.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: directoryPath,
-        }));
-        return {
-            diagnostics,
-            sandbox: null,
-            sandboxWorkspace: null,
-        };
-    }
-    let sandbox = null;
-    if (hasModule) {
-        sandbox = createModuleSourceRef({
-            logicalPath: join(SANDBOX_DIRECTORY_NAME, moduleFileName),
-        });
-    }
-    let sandboxWorkspace = null;
-    if (hasWorkspace) {
-        const workspacePath = join(directoryPath, SANDBOX_WORKSPACE_DIRECTORY_NAME);
-        const workspaceLogicalPath = normalizeLogicalPath(join(SANDBOX_DIRECTORY_NAME, SANDBOX_WORKSPACE_DIRECTORY_NAME));
-        const reservedSkillsDiagnostic = await checkWorkspaceSkillsReservation(input.source, workspacePath);
-        if (reservedSkillsDiagnostic !== null) {
-            diagnostics.push(reservedSkillsDiagnostic);
-        }
-        else {
-            const rootEntries = await collectWorkspaceRootEntries(input.source, workspacePath);
-            sandboxWorkspace = {
-                logicalPath: workspaceLogicalPath,
-                rootEntries,
-                sourceId: createPathDerivedSourceId(workspaceLogicalPath),
-                sourcePath: workspacePath,
-            };
-        }
-    }
-    return {
-        diagnostics,
-        sandbox,
-        sandboxWorkspace,
-    };
-}
-/**
- * Discovers a top-level `sandbox.<ext>` module when the agent has no
- * `sandbox/` folder. Provides a workspace-less shorthand for agents
- * that only need a sandbox definition; the folder layout remains
- * available whenever a `workspace/` subtree is required.
- */
-function discoverRootSandboxModule(input) {
-    const candidates = collectFlatSlotCandidates(input.rootEntries, {
-        moduleBaseName: SANDBOX_DEFINITION_BASE_NAME,
-    });
-    if (candidates.moduleFileNames.length > 1) {
-        input.diagnostics.push(createDiscoverErrorDiagnostic({
-            code: DISCOVER_MODULE_SLOT_COLLISION,
-            message: `Found multiple top-level sandbox definition modules: ` +
-                candidates.moduleFileNames.map((name) => `"${name}"`).join(", "),
-            sourcePath: input.rootPath,
-        }));
-        return {
-            diagnostics: input.diagnostics,
-            sandbox: null,
-            sandboxWorkspace: null,
-        };
-    }
-    const [moduleFileName] = candidates.moduleFileNames;
-    if (moduleFileName === undefined) {
-        return {
-            diagnostics: input.diagnostics,
-            sandbox: null,
-            sandboxWorkspace: null,
-        };
-    }
-    return {
-        diagnostics: input.diagnostics,
-        sandbox: createModuleSourceRef({
-            logicalPath: moduleFileName,
-        }),
-        sandboxWorkspace: null,
-    };
-}
-/**
- * Returns the file names inside the sandbox folder that match the
- * `sandbox.<ext>` definition slot. The result is sorted for stable
- * collision diagnostics.
- */
-function collectFolderSandboxModuleCandidates(entries) {
-    const moduleEntries = entries.filter((entry) => entry.isFile());
-    const candidates = [];
-    for (const candidate of collectNamedSlotCandidates(moduleEntries, {
-        allowMarkdown: false,
-        allowModules: true,
-    })) {
-        if (candidate.slotName === SANDBOX_DEFINITION_BASE_NAME) {
-            candidates.push(...candidate.moduleFileNames);
-        }
-    }
-    return candidates;
-}
-/**
- * Walks the top of an authored workspace folder and returns the
- * file/directory names ordered alphabetically. Directories are
- * suffixed with `/` so the workspace prompt section can render them
- * recognizably.
- */
-async function collectWorkspaceRootEntries(source, workspacePath) {
-    const entries = await readSortedDirectoryEntries(source, workspacePath);
-    const rendered = [];
-    for (const entry of entries) {
-        if (entry.isDirectory()) {
-            rendered.push(`${entry.name}/`);
-            continue;
-        }
-        if (entry.isFile()) {
-            rendered.push(entry.name);
-        }
-    }
-    return rendered;
-}
-/**
- * Returns a diagnostic when the sandbox workspace folder declares a
- * `skills/` subtree, since that path is reserved for the framework's
- * skill discovery.
- */
-async function checkWorkspaceSkillsReservation(source, workspacePath) {
-    const entries = await readSortedDirectoryEntries(source, workspacePath);
-    const skillsEntry = entries.find((entry) => entry.name === "skills");
-    if (skillsEntry === undefined) {
-        return null;
-    }
-    return 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(workspacePath, "skills"),
-    });
-}
+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";var 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.js

@@ -1,41 +1 @@
-import { join } from "node:path";
-import { lowerScheduleMarkdown } from "#internal/helpers/markdown.js";
-import { discoverNamedSourceDirectory } from "#discover/grammar.js";
-/**
- * Diagnostic emitted when the authored `schedules/` root exists but is not
- * a directory.
- */
-export 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 const DISCOVER_SCHEDULE_FILE_UNSUPPORTED = "discover/schedule-file-unsupported";
-/**
- * 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 async function discoverScheduleSources(input) {
-    const schedulesRoot = join(input.agentRoot, "schedules");
-    const result = await discoverNamedSourceDirectory({
-        allowMarkdown: true,
-        directoryName: "schedules",
-        invalidDirectoryCode: DISCOVER_SCHEDULES_DIRECTORY_INVALID,
-        invalidDirectoryMessage: `Expected "${schedulesRoot}" to be a directory of authored schedules.`,
-        markdownLowerer: (markdown) => lowerScheduleMarkdown(markdown),
-        recursive: true,
-        rootEntries: input.rootEntries,
-        rootPath: input.agentRoot,
-        source: input.source,
-        unsupportedFileCode: DISCOVER_SCHEDULE_FILE_UNSUPPORTED,
-        unsupportedFileMessage: (sourcePath) => `Expected "${sourcePath}" to be a TypeScript or markdown schedule file within "schedules/".`,
-    });
-    return {
-        diagnostics: result.diagnostics,
-        schedules: result.sources,
-    };
-}
+import{join}from"node:path";import{discoverNamedSourceDirectory}from"#discover/grammar.js";import{lowerScheduleMarkdown}from"#internal/helpers/markdown.js";var 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.js

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

@@ -1,68 +1 @@
-import { getSupportedModuleBaseName } from "#discover/filesystem.js";
-/**
- * Collects markdown and module candidates for one flat slot in one directory.
- */
-export function collectFlatSlotCandidates(entries, input) {
-    const candidates = {
-        moduleFileNames: [],
-    };
-    for (const entry of entries) {
-        if (!entry.isFile()) {
-            continue;
-        }
-        if (input.markdownFileName !== undefined && entry.name === input.markdownFileName) {
-            candidates.markdownFileName = entry.name;
-            continue;
-        }
-        if (input.moduleBaseName !== undefined &&
-            getSupportedModuleBaseName(entry.name) === input.moduleBaseName) {
-            candidates.moduleFileNames.push(entry.name);
-        }
-    }
-    candidates.moduleFileNames.sort((left, right) => left.localeCompare(right));
-    return candidates;
-}
-/**
- * Groups markdown and module candidates for directory-backed named slots.
- */
-export function collectNamedSlotCandidates(entries, input) {
-    const candidatesBySlotName = new Map();
-    for (const entry of entries) {
-        if (!entry.isFile()) {
-            continue;
-        }
-        const markdownSlotName = input.allowMarkdown ? getMarkdownSlotName(entry.name) : null;
-        const moduleSlotName = input.allowModules ? getSupportedModuleBaseName(entry.name) : null;
-        const slotName = markdownSlotName ?? moduleSlotName;
-        if (slotName === null) {
-            continue;
-        }
-        let slotCandidates = candidatesBySlotName.get(slotName);
-        if (slotCandidates === undefined) {
-            slotCandidates = {
-                moduleFileNames: [],
-                slotName,
-            };
-            candidatesBySlotName.set(slotName, slotCandidates);
-        }
-        if (markdownSlotName !== null) {
-            slotCandidates.markdownFileName = entry.name;
-            continue;
-        }
-        if (moduleSlotName !== null) {
-            slotCandidates.moduleFileNames.push(entry.name);
-        }
-    }
-    return [...candidatesBySlotName.values()]
-        .map((slotCandidates) => {
-        slotCandidates.moduleFileNames.sort((left, right) => left.localeCompare(right));
-        return slotCandidates;
-    })
-        .sort((left, right) => left.slotName.localeCompare(right.slotName));
-}
-function getMarkdownSlotName(name) {
-    if (!name.endsWith(".md") || name.length <= ".md".length) {
-        return null;
-    }
-    return name.slice(0, -".md".length);
-}
+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.js

@@ -1 +1 @@
-import{n as e}from"../../chunks/paths-CWZN-XRX.js";import{loadDevelopmentEnvironmentFiles as t}from"../../cli/dev/environment.js";import{n,s as r,t as i}from"../../chunks/client-ZqNLLMZB.js";import{n as a}from"../../chunks/host-CwAcCrg7.js";import{discoverAndImportSuites as o}from"../runner/discover.js";import{executeSuite as s}from"../runner/execute-suite.js";import{ConsoleReporter as c}from"../runner/reporters/console.js";var l=r();async function u(n,r){let i=e();t(i);let c=n.suite,l=await o(i,c);if(l.length===0){c&&c.length>0?r.error(`No suites found matching: ${c.join(`, `)}`):r.error(`No eval suites found. Create suite files under evals/ with the *.eval.ts extension.`),process.exitCode=1;return}let u,f;n.url?f={kind:`remote`,url:n.url}:(u=await a(i,{host:`127.0.0.1`,port:0}),f={kind:`local`,url:u.url});let p=d(f);try{let e=[];for(let t of l){let r=m(t,n),a=h(r,{json:n.json===!0,skipReport:n.skipReport===!0}),o=await s({suite:r,target:f,reporters:a,appRoot:i,client:p});e.push(o)}n.json&&r.log(JSON.stringify(e,null,2)),e.some(e=>e.errored>0)&&(process.exitCode=1)}finally{u&&await u.close()}process.exit(process.exitCode??0)}function d(e){if(e.kind===`local`)return new i({host:e.url});let t={},r=process.env.VERCEL_AUTOMATION_BYPASS_SECRET?.trim();return r&&(t[n]=r),new i({auth:f(),headers:Object.keys(t).length>0?t:void 0,host:e.url})}function f(){let e=process.env.ASH_EVAL_AUTH_TOKEN?.trim();return e?{bearer:e}:{bearer:p}}async function p(){try{let e=(await(0,l.getVercelOidcToken)()).trim();if(e.length>0)return e}catch{}return process.env.VERCEL_OIDC_TOKEN?.trim()??``}function m(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 h(e,t){let n=t.json?[]:[new c];return!t.skipReport&&e.reporters&&n.push(...e.reporters),n}export{u as runEvalCommand};
+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.ASH_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.js

@@ -1 +1 @@
-function e(e){t(e);let n=e.load??(()=>Promise.resolve([...e.cases]));return{...e,load:n,_tag:`AshEvalSuite`}}function t(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{e as defineEvalSuite};
+function defineEvalSuite(e){validateSuiteInput(e);let t=e.load??(()=>Promise.resolve([...e.cases]));return{...e,load:t,_tag:`AshEvalSuite`}}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.js

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

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

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