experimental-ash 0.26.0 → 0.28.0

package/dist/src/discover/manifest.js

@@ -1,136 +1 @@
-import { basename, relative, resolve } from "node:path";
-import { summarizeDiscoverDiagnostics } from "#discover/diagnostics.js";
-import { normalizeLogicalPath } from "#discover/filesystem.js";
-/**
- * Stable manifest kind emitted by discovery.
- */
-export const AGENT_SOURCE_MANIFEST_KIND = "ash-agent-discovery-manifest";
-/**
- * Current manifest schema version.
- */
-export const AGENT_SOURCE_MANIFEST_VERSION = 12;
-/**
- * Creates a versioned discovery manifest with stable empty-array defaults.
- */
-export function createAgentSourceManifest(input) {
-    const appRoot = resolve(input.appRoot);
-    const agentRoot = resolve(input.agentRoot);
-    const manifest = {
-        agentId: input.agentId ?? deriveAgentIdFromRoots(appRoot, agentRoot, input.packageName),
-        agentRoot,
-        appRoot,
-        channels: [...(input.channels ?? [])],
-        connections: [...(input.connections ?? [])],
-        diagnosticsSummary: summarizeDiscoverDiagnostics(input.diagnostics ?? []),
-        hooks: [...(input.hooks ?? [])],
-        lib: [...(input.lib ?? [])],
-        kind: AGENT_SOURCE_MANIFEST_KIND,
-        sandbox: input.sandbox ?? null,
-        sandboxWorkspaces: [...(input.sandboxWorkspaces ?? [])],
-        schedules: [...(input.schedules ?? [])],
-        skills: [...(input.skills ?? [])],
-        tools: [...(input.tools ?? [])],
-        version: AGENT_SOURCE_MANIFEST_VERSION,
-        subagents: [...(input.subagents ?? [])],
-    };
-    if (input.configModule !== undefined) {
-        manifest.configModule = input.configModule;
-    }
-    if (input.instructions !== undefined) {
-        manifest.instructions = input.instructions;
-    }
-    return manifest;
-}
-/**
- * Derives a stable agent id from the resolved app and agent roots.
- *
- * When `packageName` is provided it is preferred over `basename(appRoot)` so
- * that builds running inside synthetic CI working directories (e.g.
- * `/vercel/path0`) produce a meaningful agent id instead of `"path0"`.
- */
-export function deriveAgentIdFromRoots(appRoot, agentRoot, packageName) {
-    const relativeAgentRoot = normalizeLogicalPath(relative(appRoot, agentRoot));
-    if (relativeAgentRoot === "" || relativeAgentRoot === ".") {
-        return packageName ?? basename(appRoot);
-    }
-    if (relativeAgentRoot === "agent") {
-        return packageName ?? basename(appRoot);
-    }
-    return basename(agentRoot);
-}
-/**
- * Creates a stable path-derived source id for manifest entries.
- */
-export function createPathDerivedSourceId(logicalPath) {
-    return normalizeLogicalPath(logicalPath);
-}
-/**
- * Creates a module source ref while omitting optional undefined fields.
- */
-export function createModuleSourceRef(input) {
-    const logicalPath = normalizeLogicalPath(input.logicalPath);
-    const moduleSourceRef = {
-        sourceKind: "module",
-        logicalPath,
-        sourceId: input.sourceId ?? createPathDerivedSourceId(logicalPath),
-    };
-    if (input.exportName !== undefined) {
-        moduleSourceRef.exportName = input.exportName;
-    }
-    return moduleSourceRef;
-}
-/**
- * Creates a connection source ref tagged with its authored name.
- */
-export function createConnectionSourceRef(input) {
-    return {
-        ...createModuleSourceRef(input),
-        connectionName: input.connectionName,
-    };
-}
-/**
- * Creates a local subagent source ref while omitting optional undefined fields.
- */
-export function createLocalSubagentSourceRef(input) {
-    const logicalPath = normalizeLogicalPath(input.logicalPath);
-    return {
-        entryPath: input.entryPath,
-        logicalPath,
-        manifest: input.manifest,
-        rootPath: input.rootPath,
-        sourceId: input.sourceId ?? createPathDerivedSourceId(logicalPath),
-        subagentId: input.subagentId,
-    };
-}
-/**
- * Creates a skill package source ref while omitting optional undefined fields.
- */
-export function createSkillPackageSourceRef(input) {
-    const skillSourceRef = {
-        description: input.description,
-        sourceKind: "skill-package",
-        logicalPath: normalizeLogicalPath(input.logicalPath),
-        markdown: input.markdown,
-        name: input.name,
-        rootPath: input.rootPath,
-        skillFilePath: input.skillFilePath,
-        skillId: input.skillId,
-        sourceId: input.sourceId,
-    };
-    if (input.assetsPath !== undefined) {
-        skillSourceRef.assetsPath = input.assetsPath;
-    }
-    if (input.license !== undefined) {
-        skillSourceRef.license = input.license;
-    }
-    if (input.metadata !== undefined) {
-        skillSourceRef.metadata = { ...input.metadata };
-    }
-    if (input.referencesPath !== undefined) {
-        skillSourceRef.referencesPath = input.referencesPath;
-    }
-    if (input.scriptsPath !== undefined) {
-        skillSourceRef.scriptsPath = input.scriptsPath;
-    }
-    return skillSourceRef;
-}
+import{basename,relative,resolve}from"node:path";import{summarizeDiscoverDiagnostics}from"#discover/diagnostics.js";import{normalizeLogicalPath}from"#discover/filesystem.js";var AGENT_SOURCE_MANIFEST_KIND=`ash-agent-discovery-manifest`,AGENT_SOURCE_MANIFEST_VERSION=12;function createAgentSourceManifest(e){let t=resolve(e.appRoot),i=resolve(e.agentRoot),o={agentId:e.agentId??deriveAgentIdFromRoots(t,i,e.packageName),agentRoot:i,appRoot:t,channels:[...e.channels??[]],connections:[...e.connections??[]],diagnosticsSummary:summarizeDiscoverDiagnostics(e.diagnostics??[]),hooks:[...e.hooks??[]],lib:[...e.lib??[]],kind:AGENT_SOURCE_MANIFEST_KIND,sandbox:e.sandbox??null,sandboxWorkspaces:[...e.sandboxWorkspaces??[]],schedules:[...e.schedules??[]],skills:[...e.skills??[]],tools:[...e.tools??[]],version:12,subagents:[...e.subagents??[]]};return e.configModule!==void 0&&(o.configModule=e.configModule),e.instructions!==void 0&&(o.instructions=e.instructions),o}function deriveAgentIdFromRoots(n,r,a){let o=normalizeLogicalPath(relative(n,r));return o===``||o===`.`||o===`agent`?a??basename(n):basename(r)}function createPathDerivedSourceId(e){return normalizeLogicalPath(e)}function createModuleSourceRef(e){let t=normalizeLogicalPath(e.logicalPath),n={sourceKind:`module`,logicalPath:t,sourceId:e.sourceId??createPathDerivedSourceId(t)};return e.exportName!==void 0&&(n.exportName=e.exportName),n}function createConnectionSourceRef(e){return{...createModuleSourceRef(e),connectionName:e.connectionName}}function createLocalSubagentSourceRef(e){let t=normalizeLogicalPath(e.logicalPath);return{entryPath:e.entryPath,logicalPath:t,manifest:e.manifest,rootPath:e.rootPath,sourceId:e.sourceId??createPathDerivedSourceId(t),subagentId:e.subagentId}}function createSkillPackageSourceRef(e){let t={description:e.description,sourceKind:`skill-package`,logicalPath:normalizeLogicalPath(e.logicalPath),markdown:e.markdown,name:e.name,rootPath:e.rootPath,skillFilePath:e.skillFilePath,skillId:e.skillId,sourceId:e.sourceId};return e.assetsPath!==void 0&&(t.assetsPath=e.assetsPath),e.license!==void 0&&(t.license=e.license),e.metadata!==void 0&&(t.metadata={...e.metadata}),e.referencesPath!==void 0&&(t.referencesPath=e.referencesPath),e.scriptsPath!==void 0&&(t.scriptsPath=e.scriptsPath),t}export{AGENT_SOURCE_MANIFEST_KIND,AGENT_SOURCE_MANIFEST_VERSION,createAgentSourceManifest,createConnectionSourceRef,createLocalSubagentSourceRef,createModuleSourceRef,createPathDerivedSourceId,createSkillPackageSourceRef,deriveAgentIdFromRoots};

package/dist/src/discover/markdown.js

@@ -1,17 +1 @@
-import { normalizeLogicalPath, stripLogicalPathExtension } from "#discover/filesystem.js";
-import { createPathDerivedSourceId } from "#discover/manifest.js";
-/**
- * Reads one markdown-authored source from a {@link ProjectSource} and lowers
- * it into the shared manifest shape.
- */
-export async function discoverMarkdownSource(input) {
-    const logicalPath = normalizeLogicalPath(input.logicalPath);
-    return {
-        definition: input.lower(await input.source.readTextFile(input.sourcePath), {
-            name: stripLogicalPathExtension(logicalPath),
-        }),
-        sourceKind: "markdown",
-        logicalPath,
-        sourceId: createPathDerivedSourceId(logicalPath),
-    };
-}
+import{normalizeLogicalPath,stripLogicalPathExtension}from"#discover/filesystem.js";import{createPathDerivedSourceId}from"#discover/manifest.js";async function discoverMarkdownSource(e){let t=normalizeLogicalPath(e.logicalPath);return{definition:e.lower(await e.source.readTextFile(e.sourcePath),{name:stripLogicalPathExtension(t)}),sourceKind:`markdown`,logicalPath:t,sourceId:createPathDerivedSourceId(t)}}export{discoverMarkdownSource};

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

@@ -1,188 +1 @@
-import { join } from "node:path";
-import { createDiscoverErrorDiagnostic } from "#discover/diagnostics.js";
-import { getDirectoryEntryType, getSupportedModuleBaseName, normalizeLogicalPath, } from "#discover/filesystem.js";
-import { createModuleSlotCollisionDiagnostic, createSlotCollisionDiagnostic, readSortedDirectoryEntries, } from "#discover/grammar.js";
-import { createModuleSourceRef } from "#discover/manifest.js";
-import { discoverMarkdownSource } from "#discover/markdown.js";
-import { collectNamedSlotCandidates } from "#discover/slots.js";
-export async function discoverNamedSourceDirectory(input) {
-    const directoryPath = join(input.rootPath, input.directoryName);
-    const directoryEntry = input.rootEntries.find((entry) => entry.name === input.directoryName);
-    if (directoryEntry === undefined) {
-        return { diagnostics: [], sources: [] };
-    }
-    if (!directoryEntry.isDirectory()) {
-        return {
-            diagnostics: [
-                createDiscoverErrorDiagnostic({
-                    code: input.invalidDirectoryCode,
-                    message: input.invalidDirectoryMessage,
-                    sourcePath: directoryPath,
-                }),
-            ],
-            sources: [],
-        };
-    }
-    const diagnostics = [];
-    const sources = [];
-    await walkNamedSourceDirectory({
-        allowMarkdown: input.allowMarkdown === true,
-        diagnostics,
-        markdownLowerer: input.allowMarkdown === true
-            ? input.markdownLowerer
-            : undefined,
-        projectSource: input.source,
-        recursive: input.recursive,
-        relativeDirectory: input.directoryName,
-        rootDirectoryPath: directoryPath,
-        sources,
-        subdirectoryRelative: "",
-        unsupportedEntryCode: input.unsupportedEntryCode,
-        unsupportedEntryMessage: input.unsupportedEntryMessage,
-        unsupportedFileCode: input.unsupportedFileCode,
-        unsupportedFileMessage: input.unsupportedFileMessage,
-        validateSegment: input.validateSegment,
-    });
-    return { diagnostics, sources };
-}
-async function walkNamedSourceDirectory(input) {
-    const absoluteDirectory = input.subdirectoryRelative === ""
-        ? input.rootDirectoryPath
-        : join(input.rootDirectoryPath, input.subdirectoryRelative);
-    const directoryEntries = await readSortedDirectoryEntries(input.projectSource, absoluteDirectory);
-    // Recurse into subdirectories first so deeply-nested files appear in a
-    // stable, depth-first order. Skipped entirely when `recursive` is false
-    // (eg. flat `tools/` slot).
-    if (input.recursive) {
-        await walkSubdirectories(input, directoryEntries, absoluteDirectory);
-    }
-    if (input.unsupportedFileCode !== undefined || input.unsupportedEntryCode !== undefined) {
-        emitUnsupportedLeafDiagnostics(input, directoryEntries, absoluteDirectory);
-    }
-    await collectLeafSources(input, directoryEntries, absoluteDirectory);
-}
-async function walkSubdirectories(input, directoryEntries, absoluteDirectory) {
-    for (const entry of directoryEntries) {
-        if (!entry.isDirectory()) {
-            continue;
-        }
-        const segmentPath = join(absoluteDirectory, entry.name);
-        if (input.validateSegment !== undefined) {
-            const segmentDiagnostic = input.validateSegment(entry.name, segmentPath);
-            if (segmentDiagnostic !== null) {
-                input.diagnostics.push(segmentDiagnostic);
-                continue;
-            }
-        }
-        await walkNamedSourceDirectory({
-            allowMarkdown: input.allowMarkdown,
-            diagnostics: input.diagnostics,
-            markdownLowerer: input.markdownLowerer,
-            projectSource: input.projectSource,
-            recursive: input.recursive,
-            relativeDirectory: input.relativeDirectory,
-            rootDirectoryPath: input.rootDirectoryPath,
-            sources: input.sources,
-            subdirectoryRelative: input.subdirectoryRelative === ""
-                ? entry.name
-                : join(input.subdirectoryRelative, entry.name),
-            unsupportedEntryCode: input.unsupportedEntryCode,
-            unsupportedEntryMessage: input.unsupportedEntryMessage,
-            unsupportedFileCode: input.unsupportedFileCode,
-            unsupportedFileMessage: input.unsupportedFileMessage,
-            validateSegment: input.validateSegment,
-        });
-    }
-}
-function emitUnsupportedLeafDiagnostics(input, directoryEntries, absoluteDirectory) {
-    for (const entry of directoryEntries) {
-        const entryType = getDirectoryEntryType(entry);
-        const entryPath = join(absoluteDirectory, entry.name);
-        if (entryType === "directory") {
-            continue;
-        }
-        if (entryType === "other") {
-            if (input.unsupportedEntryCode !== undefined) {
-                input.diagnostics.push(createDiscoverErrorDiagnostic({
-                    code: input.unsupportedEntryCode,
-                    message: input.unsupportedEntryMessage?.(entryPath, input.relativeDirectory) ??
-                        `Expected "${entryPath}" to be a regular file or directory within "${input.relativeDirectory}/".`,
-                    sourcePath: entryPath,
-                }));
-            }
-            continue;
-        }
-        if (input.unsupportedFileCode === undefined) {
-            continue;
-        }
-        const isModule = getSupportedModuleBaseName(entry.name) !== null;
-        const isMarkdown = input.allowMarkdown && entry.name.endsWith(".md");
-        if (isModule || isMarkdown) {
-            continue;
-        }
-        input.diagnostics.push(createDiscoverErrorDiagnostic({
-            code: input.unsupportedFileCode,
-            message: input.unsupportedFileMessage?.(entryPath, input.relativeDirectory) ??
-                `Expected "${entryPath}" to be a supported authored source within "${input.relativeDirectory}/".`,
-            sourcePath: entryPath,
-        }));
-    }
-}
-async function collectLeafSources(input, directoryEntries, absoluteDirectory) {
-    for (const candidates of collectNamedSlotCandidates(directoryEntries, {
-        allowMarkdown: input.allowMarkdown,
-        allowModules: true,
-    })) {
-        const slotSubpath = input.subdirectoryRelative === ""
-            ? candidates.slotName
-            : join(input.subdirectoryRelative, candidates.slotName);
-        const slotLogicalPath = normalizeLogicalPath(join(input.relativeDirectory, slotSubpath));
-        if (input.validateSegment !== undefined) {
-            const probeFileName = candidates.markdownFileName ?? candidates.moduleFileNames[0] ?? candidates.slotName;
-            const segmentDiagnostic = input.validateSegment(candidates.slotName, join(absoluteDirectory, probeFileName));
-            if (segmentDiagnostic !== null) {
-                input.diagnostics.push(segmentDiagnostic);
-                continue;
-            }
-        }
-        if (candidates.markdownFileName !== undefined && candidates.moduleFileNames.length > 0) {
-            input.diagnostics.push(createSlotCollisionDiagnostic(absoluteDirectory, slotLogicalPath, [
-                candidates.markdownFileName,
-                ...candidates.moduleFileNames,
-            ]));
-            continue;
-        }
-        if (candidates.moduleFileNames.length > 1) {
-            input.diagnostics.push(createModuleSlotCollisionDiagnostic(absoluteDirectory, slotLogicalPath, candidates.moduleFileNames));
-            continue;
-        }
-        if (candidates.markdownFileName !== undefined) {
-            const fileSubpath = input.subdirectoryRelative === ""
-                ? candidates.markdownFileName
-                : join(input.subdirectoryRelative, candidates.markdownFileName);
-            const markdownLogicalPath = normalizeLogicalPath(join(input.relativeDirectory, fileSubpath));
-            if (input.markdownLowerer === undefined) {
-                // Defensive: should never happen because allowMarkdown gates lower.
-                continue;
-            }
-            const markdownRef = await discoverMarkdownSource({
-                logicalPath: markdownLogicalPath,
-                lower: input.markdownLowerer,
-                source: input.projectSource,
-                sourcePath: join(input.rootDirectoryPath, fileSubpath),
-            });
-            input.sources.push(markdownRef);
-            continue;
-        }
-        const [logicalFileName] = candidates.moduleFileNames;
-        if (logicalFileName === undefined) {
-            continue;
-        }
-        const fileSubpath = input.subdirectoryRelative === ""
-            ? logicalFileName
-            : join(input.subdirectoryRelative, logicalFileName);
-        input.sources.push(createModuleSourceRef({
-            logicalPath: normalizeLogicalPath(join(input.relativeDirectory, fileSubpath)),
-        }));
-    }
-}
+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.js

@@ -1,152 +1 @@
-import { readdir, readFile, stat } from "node:fs/promises";
-import { posix, sep } from "node:path";
-/**
- * Creates a {@link ProjectSource} backed by the real filesystem. This is the
- * default for production and for the scenario tier.
- */
-export function createDiskProjectSource() {
-    return {
-        kind: "disk",
-        async readDirectory(directoryPath) {
-            return await readdir(directoryPath, { withFileTypes: true });
-        },
-        async readTextFile(filePath) {
-            return await readFile(filePath, "utf8");
-        },
-        async stat(targetPath) {
-            try {
-                const stats = await stat(targetPath);
-                if (stats.isDirectory()) {
-                    return "directory";
-                }
-                if (stats.isFile()) {
-                    return "file";
-                }
-                return "other";
-            }
-            catch {
-                return "missing";
-            }
-        },
-    };
-}
-/**
- * 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 function createMemoryProjectSource(input) {
-    const filesByNormalizedPath = new Map();
-    const directoriesByNormalizedPath = new Map();
-    function registerDirectory(normalizedDirectoryPath) {
-        let entries = directoriesByNormalizedPath.get(normalizedDirectoryPath);
-        if (entries === undefined) {
-            entries = new Map();
-            directoriesByNormalizedPath.set(normalizedDirectoryPath, entries);
-        }
-        return entries;
-    }
-    function registerChildOfDirectory(normalizedDirectoryPath, childName, childKind) {
-        const existing = registerDirectory(normalizedDirectoryPath).get(childName);
-        if (existing === "file" && childKind === "directory") {
-            throw new TypeError(`MemoryProjectSource: path "${posix.join(normalizedDirectoryPath, childName)}" registered as both a file and a directory.`);
-        }
-        registerDirectory(normalizedDirectoryPath).set(childName, childKind);
-    }
-    for (const [rawPath, value] of Object.entries(input.files)) {
-        const normalizedPath = normalizeToPosix(rawPath);
-        const content = typeof value === "string" ? value : value.content;
-        filesByNormalizedPath.set(normalizedPath, content);
-        const segments = splitPosixPath(normalizedPath);
-        if (segments.length === 0) {
-            throw new TypeError(`MemoryProjectSource: cannot register root path "${rawPath}" as a file.`);
-        }
-        const fileName = segments[segments.length - 1];
-        if (fileName === undefined) {
-            throw new TypeError(`MemoryProjectSource: empty file name in "${rawPath}".`);
-        }
-        let currentDirectoryPath = "/";
-        for (let index = 0; index < segments.length - 1; index += 1) {
-            const segment = segments[index];
-            if (segment === undefined) {
-                continue;
-            }
-            registerChildOfDirectory(currentDirectoryPath, segment, "directory");
-            currentDirectoryPath =
-                currentDirectoryPath === "/" ? `/${segment}` : `${currentDirectoryPath}/${segment}`;
-        }
-        registerChildOfDirectory(currentDirectoryPath, fileName, "file");
-    }
-    for (const rawDirectoryPath of input.directories ?? []) {
-        const normalizedDirectoryPath = normalizeToPosix(rawDirectoryPath);
-        const directorySegments = splitPosixPath(normalizedDirectoryPath);
-        registerDirectory(normalizedDirectoryPath);
-        let ancestorDirectoryPath = "/";
-        for (let index = 0; index < directorySegments.length; index += 1) {
-            const segment = directorySegments[index];
-            if (segment === undefined) {
-                continue;
-            }
-            registerChildOfDirectory(ancestorDirectoryPath, segment, "directory");
-            ancestorDirectoryPath =
-                ancestorDirectoryPath === "/" ? `/${segment}` : `${ancestorDirectoryPath}/${segment}`;
-        }
-    }
-    return {
-        kind: "memory",
-        async readDirectory(directoryPath) {
-            const normalized = normalizeToPosix(directoryPath);
-            const entries = directoriesByNormalizedPath.get(normalized);
-            if (entries === undefined) {
-                throw new Error(`MemoryProjectSource: directory "${directoryPath}" does not exist${input.rootDir === undefined ? "" : ` (root: ${input.rootDir})`}.`);
-            }
-            return [...entries.entries()].map(([name, kind]) => createMemoryEntry(name, kind));
-        },
-        async readTextFile(filePath) {
-            const normalized = normalizeToPosix(filePath);
-            const content = filesByNormalizedPath.get(normalized);
-            if (content === undefined) {
-                throw new Error(`MemoryProjectSource: file "${filePath}" does not exist${input.rootDir === undefined ? "" : ` (root: ${input.rootDir})`}.`);
-            }
-            return content;
-        },
-        async stat(targetPath) {
-            const normalized = normalizeToPosix(targetPath);
-            if (filesByNormalizedPath.has(normalized)) {
-                return "file";
-            }
-            if (directoriesByNormalizedPath.has(normalized)) {
-                return "directory";
-            }
-            return "missing";
-        },
-    };
-}
-function createMemoryEntry(name, kind) {
-    return {
-        name,
-        isDirectory() {
-            return kind === "directory";
-        },
-        isFile() {
-            return kind === "file";
-        },
-    };
-}
-function normalizeToPosix(path) {
-    const withPosixSeparators = sep === "/" ? path : path.replaceAll(sep, "/");
-    if (withPosixSeparators.length === 0) {
-        return "/";
-    }
-    // Strip a Windows drive letter (`C:`) if present — the in-memory source
-    // treats all paths as POSIX-rooted for determinism across platforms.
-    const driveStripped = withPosixSeparators.replace(/^[A-Za-z]:/, "");
-    const withLeadingSlash = driveStripped.startsWith("/") ? driveStripped : `/${driveStripped}`;
-    return posix.normalize(withLeadingSlash).replace(/\/+$/, "") || "/";
-}
-function splitPosixPath(normalizedPath) {
-    return normalizedPath.split("/").filter((segment) => segment.length > 0);
-}
+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.js

@@ -1,117 +1 @@
-import { basename, dirname, join, resolve } from "node:path";
-import { createDiscoverErrorDiagnostic, DISCOVER_PROJECT_NOT_FOUND, } from "#discover/diagnostics.js";
-import { classifyAgentRootEntry, getDirectoryEntryType, isProjectMarkerEntry, } from "#discover/filesystem.js";
-import { createDiskProjectSource } from "#discover/project-source.js";
-/**
- * Error raised when discovery cannot resolve an Ash agent root from a
- * {@link ProjectSource}.
- */
-export class DiscoveryProjectResolutionError extends Error {
-    diagnostic;
-    constructor(diagnostic) {
-        super(diagnostic.message);
-        this.name = "DiscoveryProjectResolutionError";
-        this.diagnostic = diagnostic;
-    }
-}
-/**
- * Resolves the nearest Ash 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 async function resolveDiscoveryProject(startPath = process.cwd(), options = {}) {
-    const source = options.source ?? createDiskProjectSource();
-    const startDirectory = await resolveSearchDirectory(source, startPath);
-    let currentDirectory = startDirectory;
-    while (true) {
-        const nestedProjectFromAgentDirectory = await tryResolveNestedProjectFromAgentDirectory(source, currentDirectory);
-        if (nestedProjectFromAgentDirectory !== null) {
-            return nestedProjectFromAgentDirectory;
-        }
-        const nestedProjectFromAppRoot = await tryResolveNestedProjectFromAppRoot(source, currentDirectory);
-        if (nestedProjectFromAppRoot !== null) {
-            return nestedProjectFromAppRoot;
-        }
-        if (await isFlatAgentRoot(source, currentDirectory)) {
-            return {
-                agentRoot: currentDirectory,
-                appRoot: currentDirectory,
-                layout: "flat",
-            };
-        }
-        const parentDirectory = dirname(currentDirectory);
-        if (parentDirectory === currentDirectory) {
-            break;
-        }
-        currentDirectory = parentDirectory;
-    }
-    throw new DiscoveryProjectResolutionError(createDiscoverErrorDiagnostic({
-        code: DISCOVER_PROJECT_NOT_FOUND,
-        message: `Could not resolve an Ash agent root from "${startDirectory}".`,
-        sourcePath: startDirectory,
-    }));
-}
-async function resolveSearchDirectory(source, startPath) {
-    const resolvedPath = resolve(startPath);
-    const kind = await source.stat(resolvedPath);
-    if (kind === "directory") {
-        return resolvedPath;
-    }
-    return dirname(resolvedPath);
-}
-async function tryResolveNestedProjectFromAgentDirectory(source, directoryPath) {
-    if (basename(directoryPath) !== "agent") {
-        return null;
-    }
-    const parentDirectory = dirname(directoryPath);
-    if (!(await hasProjectMarkers(source, parentDirectory))) {
-        return null;
-    }
-    return {
-        agentRoot: directoryPath,
-        appRoot: parentDirectory,
-        layout: "nested",
-    };
-}
-async function tryResolveNestedProjectFromAppRoot(source, directoryPath) {
-    if (!(await hasProjectMarkers(source, directoryPath))) {
-        return null;
-    }
-    const agentDirectory = join(directoryPath, "agent");
-    if (!(await directoryExists(source, agentDirectory))) {
-        return null;
-    }
-    return {
-        agentRoot: agentDirectory,
-        appRoot: directoryPath,
-        layout: "nested",
-    };
-}
-async function isFlatAgentRoot(source, directoryPath) {
-    const entries = await readDirectoryEntryTypes(source, directoryPath);
-    return Array.from(entries.entries()).some(([name, entryType]) => {
-        const entryKind = classifyAgentRootEntry(name, entryType);
-        return entryKind !== "unknown" && entryKind !== "lib-directory";
-    });
-}
-async function hasProjectMarkers(source, directoryPath) {
-    const entries = await readDirectoryEntryTypes(source, directoryPath);
-    return Array.from(entries.entries()).some(([name, entryType]) => {
-        return isProjectMarkerEntry(name, entryType);
-    });
-}
-async function readDirectoryEntryTypes(source, directoryPath) {
-    if ((await source.stat(directoryPath)) !== "directory") {
-        return new Map();
-    }
-    const entries = await source.readDirectory(directoryPath);
-    return new Map(entries.map((entry) => {
-        return [entry.name, getDirectoryEntryType(entry)];
-    }));
-}
-async function directoryExists(source, directoryPath) {
-    return (await source.stat(directoryPath)) === "directory";
-}
+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 Ash 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};