@netlify/build-info 6.2.2 → 6.3.0

package/lib/{bin.js → node/bin.js}

@@ -1,4 +1,4 @@
-import { exit, argv } from 'process';
+import { argv, exit } from 'process';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { getBuildInfo } from './get-build-info.js';
@@ -10,8 +10,7 @@ yargs(hideBin(argv))
     },
 }), async ({ projectDir, rootDir }) => {
     try {
-        const buildInfo = await getBuildInfo({ projectDir, rootDir });
-        console.log(JSON.stringify(buildInfo, null, 2));
+        console.log(JSON.stringify(await getBuildInfo(projectDir, rootDir), null, 2));
     }
     catch (error) {
         console.error(error);

package/lib/node/file-system.d.ts

@@ -0,0 +1,19 @@
+import { DirType, FileSystem, findUpOptions } from '../file-system.js';
+export declare class NodeFS extends FileSystem {
+    constructor();
+    isAbsolute(path: string): boolean;
+    dirname(path: string): string;
+    resolve(...paths: string[]): string;
+    relative(from: string, to: string): string;
+    basename(path: string): string;
+    join(...segments: string[]): string;
+    fileExists(path: string): Promise<boolean>;
+    /** Get a list of directory entries */
+    readDir(path: string): Promise<string[]>;
+    readDir(path: string, withFileTypes: true): Promise<Record<string, DirType>>;
+    readFile(path: string): Promise<string>;
+    /** Node implementation of finding a file or directory by walking up parent directories. */
+    findUp(name: string | readonly string[], options?: findUpOptions): Promise<string | undefined>;
+    /** Node implementation of finding files or directories by walking up parent directories. */
+    findUpMultiple(name: string | readonly string[], options?: findUpOptions): Promise<string[]>;
+}

package/lib/node/file-system.js

@@ -0,0 +1,65 @@
+import { promises as fs } from 'fs';
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'path';
+import { findUp, findUpMultiple } from 'find-up';
+import { FileSystem } from '../file-system.js';
+export class NodeFS extends FileSystem {
+    constructor() {
+        super();
+        this.cwd = process.cwd();
+    }
+    isAbsolute(path) {
+        return isAbsolute(path);
+    }
+    dirname(path) {
+        return dirname(path);
+    }
+    resolve(...paths) {
+        return resolve(...paths);
+    }
+    relative(from, to) {
+        return relative(from, to);
+    }
+    basename(path) {
+        return basename(path);
+    }
+    join(...segments) {
+        return join(...segments);
+    }
+    async fileExists(path) {
+        try {
+            await fs.stat(resolve(path));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async readDir(path, withFileTypes) {
+        try {
+            if (!withFileTypes) {
+                return fs.readdir(resolve(path));
+            }
+            const result = await fs.readdir(resolve(path), { withFileTypes: true });
+            return result.reduce((prev, cur) => ({ ...prev, [cur.name]: cur.isDirectory() ? 'directory' : 'file' }), {});
+        }
+        catch {
+            return [];
+        }
+    }
+    async readFile(path) {
+        const storedFile = this.getFile(path);
+        // no need to read again (just use the already stored file)
+        if (storedFile?.type === 'text') {
+            return storedFile.content;
+        }
+        return (await fs.readFile(resolve(path), 'utf-8')).toString();
+    }
+    /** Node implementation of finding a file or directory by walking up parent directories. */
+    findUp(name, options = {}) {
+        return findUp(name, options);
+    }
+    /** Node implementation of finding files or directories by walking up parent directories. */
+    findUpMultiple(name, options = {}) {
+        return findUpMultiple(name, options);
+    }
+}

package/lib/node/get-build-info.d.ts

@@ -0,0 +1,20 @@
+import { Logger } from '../file-system.js';
+import { PkgManagerFields } from '../package-managers/detect-package-manager.js';
+import { WorkspaceInfo } from '../workspaces/detect-workspace.js';
+export type Info = {
+    jsWorkspaces?: WorkspaceInfo;
+    packageManager?: PkgManagerFields;
+    frameworks: unknown[];
+    buildSystems?: {
+        name: string;
+        version?: string | undefined;
+    }[];
+};
+/** A noop logger that is used to not log anything (we use the stdout for parsing the json output) */
+export declare class NoopLogger implements Logger {
+    debug(): void;
+    log(): void;
+    error(): void;
+}
+/** Get the build info object that is used inside buildbot */
+export declare function getBuildInfo(projectDir?: string, rootDir?: string): Promise<Info>;

package/lib/node/get-build-info.js

@@ -0,0 +1,46 @@
+import { listFrameworks } from '@netlify/framework-info';
+import { Project } from '../project.js';
+import { NodeFS } from './file-system.js';
+/** A noop logger that is used to not log anything (we use the stdout for parsing the json output) */
+export class NoopLogger {
+    debug() {
+        /** noop */
+    }
+    log() {
+        /** noop */
+    }
+    error() {
+        /** noop */
+    }
+}
+/** Get the build info object that is used inside buildbot */
+export async function getBuildInfo(projectDir, rootDir) {
+    const fs = new NodeFS();
+    // prevent logging in output as we use the stdout to capture the json
+    fs.logger = new NoopLogger();
+    const project = new Project(fs, projectDir, rootDir);
+    project.setEnvironment(process.env);
+    let frameworks = [];
+    try {
+        // if the framework  detection is crashing we should not crash the build info and package-manager detection
+        frameworks = await listFrameworks({ projectDir: project.baseDirectory });
+    }
+    catch {
+        // TODO: build reporting to buildbot see: https://github.com/netlify/pillar-workflow/issues/1001
+        // noop
+    }
+    const info = {
+        frameworks,
+        buildSystems: await project.detectBuildSystem(),
+    };
+    const pkgJSONPath = await project.getPackageJSON();
+    // only if we find a root package.json we know this is a javascript workspace
+    if (Object.keys(pkgJSONPath).length) {
+        info.packageManager = await project.detectPackageManager();
+        const workspaceInfo = await project.detectWorkspaces();
+        if (workspaceInfo) {
+            info.jsWorkspaces = workspaceInfo;
+        }
+    }
+    return info;
+}

package/lib/{detect-package-manager.d.ts → package-managers/detect-package-manager.d.ts}

@@ -1,3 +1,4 @@
+import type { Project } from '../project.js';
 export declare const enum PkgManager {
     YARN = "yarn",
     PNPM = "pnpm",
@@ -22,8 +23,5 @@ export type PkgManagerFields = {
  * 1. packageManager field
  * 2. environment variable that forces the usage
  * 3. a lock file that is present in this directory or up in the tree for workspaces
- * @param cwd The current process working directory of the build
- * @param stopAt The repository root where it should stop looking up for package.json or lock files. (defaults to `path.parse(cwd).root`)
- * @returns The package manager that was detected
  */
-export declare const detectPackageManager: (cwd?: string, stopAt?: string) => Promise<PkgManagerFields>;
+export declare const detectPackageManager: (project: Project) => Promise<PkgManagerFields>;

package/lib/package-managers/detect-package-manager.js

@@ -0,0 +1,75 @@
+/** The definition of all available package managers */
+const AVAILABLE_PACKAGE_MANAGERS = {
+    ["yarn" /* PkgManager.YARN */]: {
+        name: "yarn" /* PkgManager.YARN */,
+        installCommand: 'yarn install',
+        lockFile: 'yarn.lock',
+        forceEnvironment: 'NETLIFY_USE_YARN',
+    },
+    ["pnpm" /* PkgManager.PNPM */]: {
+        name: "pnpm" /* PkgManager.PNPM */,
+        installCommand: 'pnpm install',
+        lockFile: 'pnpm-lock.yaml',
+        forceEnvironment: 'NETLIFY_USE_PNPM',
+    },
+    ["npm" /* PkgManager.NPM */]: {
+        name: "npm" /* PkgManager.NPM */,
+        installCommand: 'npm install',
+        lockFile: 'package-lock.json',
+    },
+};
+/**
+ * generate a map out of key is lock file and value the package manager
+ * this is to reduce the complexity in loops
+ */
+const lockFileMap = Object.values(AVAILABLE_PACKAGE_MANAGERS).reduce((cur, pkgManager) => ({ ...cur, [pkgManager.lockFile]: pkgManager }), {});
+/**
+ * Detects the used package manager based on
+ * 1. packageManager field
+ * 2. environment variable that forces the usage
+ * 3. a lock file that is present in this directory or up in the tree for workspaces
+ */
+export const detectPackageManager = async (project) => {
+    try {
+        const pkgPaths = await project.fs.findUpMultiple('package.json', {
+            cwd: project.baseDirectory,
+            stopAt: project.root,
+        });
+        for (const pkgPath of pkgPaths) {
+            const { packageManager } = await project.fs.readJSON(pkgPath);
+            if (packageManager) {
+                const [parsed] = packageManager.split('@');
+                if (AVAILABLE_PACKAGE_MANAGERS[parsed]) {
+                    return AVAILABLE_PACKAGE_MANAGERS[parsed];
+                }
+            }
+        }
+        // the package manager can be enforced via an environment variable as well
+        for (const pkgManager of Object.values(AVAILABLE_PACKAGE_MANAGERS)) {
+            if (pkgManager.forceEnvironment && project.getEnv(pkgManager.forceEnvironment) === 'true') {
+                return pkgManager;
+            }
+        }
+        // find the correct lock file the tree up
+        const lockFilePath = await project.fs.findUp(Object.keys(lockFileMap), {
+            cwd: project.baseDirectory,
+            stopAt: project.root,
+        });
+        // if we found a lock file and the usage is not prohibited through an environment variable
+        // return the found package manager
+        if (lockFilePath) {
+            const lockFile = project.fs.basename(lockFilePath);
+            const pkgManager = lockFileMap[lockFile];
+            // check if it not got disabled
+            if (!(pkgManager.forceEnvironment && project.getEnv(pkgManager.forceEnvironment) === 'false')) {
+                return pkgManager;
+            }
+        }
+    }
+    catch {
+        // noop
+    }
+    // always default to npm
+    // TODO: add some reporting here to log that we fall backed
+    return AVAILABLE_PACKAGE_MANAGERS["npm" /* PkgManager.NPM */];
+};

package/lib/project.d.ts

@@ -0,0 +1,33 @@
+import type { PackageJson } from 'read-pkg';
+import type { BuildSystem } from './build-systems/build-system.js';
+import type { FileSystem } from './file-system.js';
+import type { PkgManagerFields } from './package-managers/detect-package-manager.js';
+/**
+ * The Project represents a Site in Netlify
+ * The only configuration here needed is the path to the repository root and the optional baseDirectory
+ */
+export declare class Project {
+    #private;
+    fs: FileSystem;
+    /** An optional repository root that tells us where to stop looking up */
+    root?: string;
+    /** An absolute path  */
+    baseDirectory: string;
+    packageManager: PkgManagerFields;
+    /** an absolute path of the root directory for js workspaces where the most top package.json is located */
+    jsWorkspaceRoot: string;
+    constructor(fs: FileSystem, baseDirectory?: string, root?: string);
+    /** Set's the environment for the project */
+    setEnvironment(env: Record<string, string | undefined>): this;
+    /** retrieves an environment variable */
+    getEnv(key: string): string | undefined;
+    /** retrieves the root package.json file */
+    getRootPackageJSON(): Promise<PackageJson>;
+    getPackageJSON(startDirectory?: string): Promise<PackageJson>;
+    /** Detects the used package Manager */
+    detectPackageManager(): Promise<PkgManagerFields>;
+    /** Detects the javascript workspace settings */
+    detectWorkspaces(): Promise<import("./workspaces/detect-workspace.js").WorkspaceInfo | undefined>;
+    /** Detects all used build systems */
+    detectBuildSystem(): Promise<BuildSystem[]>;
+}

package/lib/project.js

@@ -0,0 +1,82 @@
+import { buildSystems } from './build-systems/index.js';
+import { detectPackageManager } from './package-managers/detect-package-manager.js';
+import { detectWorkspaces } from './workspaces/detect-workspace.js';
+/**
+ * The Project represents a Site in Netlify
+ * The only configuration here needed is the path to the repository root and the optional baseDirectory
+ */
+export class Project {
+    fs;
+    /** An optional repository root that tells us where to stop looking up */
+    root;
+    /** An absolute path  */
+    baseDirectory;
+    packageManager;
+    /** an absolute path of the root directory for js workspaces where the most top package.json is located */
+    jsWorkspaceRoot;
+    /** a representation of the current environment */
+    #environment = {};
+    constructor(fs, baseDirectory, root) {
+        this.fs = fs;
+        this.baseDirectory = fs.resolve(root || '', baseDirectory !== undefined ? baseDirectory : fs.cwd);
+        this.root = root ? fs.resolve(fs.cwd, root) : undefined;
+        // if the root and the base directory are the same unset the root again as its not a workspace
+        if (this.root === this.baseDirectory) {
+            this.root = undefined;
+        }
+        this.fs.cwd = this.baseDirectory;
+    }
+    /** Set's the environment for the project */
+    setEnvironment(env) {
+        this.#environment = env;
+        return this;
+    }
+    /** retrieves an environment variable */
+    getEnv(key) {
+        return this.#environment[key];
+    }
+    /** retrieves the root package.json file */
+    async getRootPackageJSON() {
+        // get the most upper json file
+        const rootJSONPath = (await this.fs.findUpMultiple('package.json', { cwd: this.baseDirectory, stopAt: this.root })).pop();
+        if (rootJSONPath) {
+            this.jsWorkspaceRoot = this.fs.dirname(rootJSONPath);
+            return this.fs.readJSON(rootJSONPath);
+        }
+        return {};
+    }
+    async getPackageJSON(startDirectory) {
+        const pkgPath = await this.fs.findUp('package.json', {
+            cwd: startDirectory || this.baseDirectory,
+            stopAt: this.root,
+        });
+        if (pkgPath) {
+            return this.fs.readJSON(pkgPath);
+        }
+        return {};
+    }
+    /** Detects the used package Manager */
+    async detectPackageManager() {
+        this.packageManager = await detectPackageManager(this);
+        return this.packageManager;
+    }
+    /** Detects the javascript workspace settings */
+    async detectWorkspaces() {
+        try {
+            return detectWorkspaces(this);
+        }
+        catch {
+            return;
+        }
+    }
+    /** Detects all used build systems */
+    async detectBuildSystem() {
+        try {
+            const detected = await Promise.all(buildSystems.map(async (BuildSystem) => (await new BuildSystem().detect(this))?.toJSON()));
+            return detected.filter(Boolean);
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/lib/workspaces/detect-workspace.d.ts

@@ -0,0 +1,22 @@
+import type { PackageJson } from 'read-pkg';
+import { Project } from '../project.js';
+export type WorkspaceInfo = {
+    /** if we are in the current workspace root or not */
+    isRoot: boolean;
+    /** the workspace root directory */
+    rootDir: string;
+    /** list of relative package paths inside the workspace */
+    packages: string[];
+};
+/**
+ * Get a list of globs about all the packages inside a pnpm workspace
+ * https://pnpm.io/pnpm-workspace_yaml
+ */
+export declare function detectPnpmWorkspaceGlobs(project: Project): Promise<string[]>;
+/** Get the workspace globs from the package.json file */
+export declare function detectNpmOrYarnWorkspaceGlobs(pkgJSON: PackageJson): Promise<string[]>;
+/**
+ * If it's a javascript workspace (npm, pnpm, yarn) it will retrieve a list of all
+ * package paths and will indicate if it's the root of the workspace
+ */
+export declare function detectWorkspaces(project: Project): Promise<WorkspaceInfo | undefined>;

package/lib/workspaces/detect-workspace.js

@@ -0,0 +1,56 @@
+import { parse } from 'yaml';
+import { getWorkspacePackages } from './get-workspace-packages.js';
+/**
+ * Get a list of globs about all the packages inside a pnpm workspace
+ * https://pnpm.io/pnpm-workspace_yaml
+ */
+export async function detectPnpmWorkspaceGlobs(project) {
+    const workspaceFile = await project.fs.findUp('pnpm-workspace.yaml', {
+        cwd: project.baseDirectory,
+        stopAt: project.root,
+    });
+    if (!workspaceFile) {
+        return [];
+    }
+    const { packages } = parse(await project.fs.readFile(workspaceFile));
+    return packages;
+}
+/** Get the workspace globs from the package.json file */
+export async function detectNpmOrYarnWorkspaceGlobs(pkgJSON) {
+    if (Array.isArray(pkgJSON.workspaces)) {
+        return pkgJSON.workspaces;
+    }
+    if (typeof pkgJSON.workspaces === 'object') {
+        return pkgJSON.workspaces.packages || [];
+    }
+    return [];
+}
+/**
+ * If it's a javascript workspace (npm, pnpm, yarn) it will retrieve a list of all
+ * package paths and will indicate if it's the root of the workspace
+ */
+export async function detectWorkspaces(project) {
+    if (!project.packageManager) {
+        throw new Error('Please run the packageManager detection before calling the workspace detection!');
+    }
+    const pkgJSON = await project.getRootPackageJSON();
+    const workspaceGlobs = project.packageManager.name === "pnpm" /* PkgManager.PNPM */
+        ? await detectPnpmWorkspaceGlobs(project)
+        : await detectNpmOrYarnWorkspaceGlobs(pkgJSON);
+    if (workspaceGlobs.length === 0) {
+        return;
+    }
+    const packages = await getWorkspacePackages(project, workspaceGlobs);
+    const isRoot = project.baseDirectory === project.jsWorkspaceRoot;
+    const relBaseDirectory = project.fs.relative(project.jsWorkspaceRoot, project.baseDirectory);
+    // if the current base directory is not part of the detected workspace packages it's not part of this workspace
+    // and therefore return no workspace info
+    if (!isRoot && !packages.includes(relBaseDirectory)) {
+        return;
+    }
+    return {
+        rootDir: project.jsWorkspaceRoot,
+        isRoot,
+        packages,
+    };
+}

package/lib/workspaces/get-workspace-packages.d.ts

@@ -0,0 +1,3 @@
+import type { Project } from '../project.js';
+/** Get a list of all workspace package paths (absolute paths) */
+export declare function getWorkspacePackages(project: Project, patterns: string[]): Promise<string[]>;

package/lib/workspaces/get-workspace-packages.js

@@ -0,0 +1,66 @@
+import minimatch, { Minimatch } from 'minimatch';
+/** Get the base directory out of a glob pattern */
+function getDirFromPattern(pattern) {
+    const dir = [];
+    const parts = pattern.globParts[0];
+    for (let i = 0, max = parts.length; i < max; i++) {
+        if (parts[i].includes('*')) {
+            // skip the rest
+            return { dir: dir.join('/'), depth: parts[i] };
+        }
+        dir.push(parts[i]);
+    }
+    return { dir: dir.join('/') };
+}
+/** Find all packages inside a provided directory */
+async function findPackages(project, dir, depth) {
+    const found = [];
+    let content = {};
+    try {
+        const startDir = project.root ? project.fs.resolve(project.root, dir) : project.fs.resolve(dir);
+        content = await project.fs.readDir(startDir, true);
+    }
+    catch (err) {
+        // noop
+    }
+    for (const [part, type] of Object.entries(content)) {
+        if (part === 'package.json') {
+            found.push(dir);
+        }
+        if (depth && type === 'directory') {
+            found.push(...(await findPackages(project, project.fs.join(dir, part), depth === '**' ? depth : undefined)));
+        }
+    }
+    return found;
+}
+/** Get a list of all workspace package paths (absolute paths) */
+export async function getWorkspacePackages(project, patterns) {
+    const results = [];
+    if (!patterns.length) {
+        return results;
+    }
+    for (const pattern of patterns) {
+        const matcher = new Minimatch(pattern);
+        // skip negated pattern for exploring as we filter at the end
+        if (matcher.negate) {
+            continue;
+        }
+        const { dir, depth } = getDirFromPattern(matcher);
+        results.push(...(await findPackages(project, dir, depth)));
+    }
+    // initially add all results to the set
+    // and filter out then the negated patterns
+    const filtered = new Set();
+    for (const result of results) {
+        for (const pattern of patterns) {
+            const matcher = new Minimatch(pattern);
+            if (minimatch(result, matcher.pattern)) {
+                filtered.add(project.fs.join(result));
+                if (matcher.negate) {
+                    filtered.delete(project.fs.join(result));
+                }
+            }
+        }
+    }
+    return [...filtered];
+}

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@netlify/build-info",
-  "version": "6.2.2",
+  "version": "6.3.0",
   "description": "Build info utility",
   "type": "module",
   "exports": {
     ".": "./lib/index.js"
   },
+  "browser": "./lib/index.js",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "bin": {
@@ -18,6 +19,7 @@
   "scripts": {
     "prebuild": "rm -rf lib",
     "build": "tsc",
+    "e2e": "playwright test",
     "test": "vitest run",
     "test:dev": "vitest --ui",
     "test:ci": "vitest run --reporter=default"
@@ -34,27 +36,30 @@
   },
   "author": "Netlify Inc.",
   "dependencies": {
-    "@netlify/framework-info": "^9.8.0",
-    "@npmcli/map-workspaces": "^2.0.0",
+    "@netlify/framework-info": "^9.8.2",
     "find-up": "^6.3.0",
+    "minimatch": "^6.2.0",
     "read-pkg": "^7.1.0",
     "yaml": "^2.1.3",
     "yargs": "^17.6.0"
   },
   "devDependencies": {
+    "@playwright/test": "^1.30.0",
     "@types/node": "^14.18.31",
     "@types/semver": "^7.3.13",
     "@vitest/coverage-c8": "^0.24.1",
     "@vitest/ui": "^0.24.3",
     "execa": "^6.0.0",
     "memfs": "^3.4.7",
+    "node-fetch": "^3.3.0",
     "semver": "^7.3.8",
     "typescript": "^4.8.4",
     "unionfs": "^4.4.0",
+    "vite": "^4.1.1",
     "vitest": "^0.24.1"
   },
   "engines": {
     "node": "^14.16.0 || >=16.0.0"
   },
-  "gitHead": "d78a65c209ed987d3475cd1f37cf357693b99e3c"
+  "gitHead": "ade6e389937eb921779b5af7268547a59741de5a"
 }

package/lib/context.d.ts

@@ -1,11 +0,0 @@
-import { PackageJson } from 'read-pkg';
-export type ContextOptions = {
-    projectDir?: string;
-    rootDir?: string;
-};
-export type Context = {
-    projectDir: string;
-    rootDir?: string;
-    rootPackageJson: PackageJson;
-};
-export declare const getContext: (config?: ContextOptions) => Promise<Context>;

package/lib/context.js

@@ -1,45 +0,0 @@
-import { existsSync } from 'fs';
-import { dirname, join, resolve } from 'path';
-import { cwd } from 'process';
-import { findUp } from 'find-up';
-import { readPackage } from 'read-pkg';
-/**
- * Collects the root package.json if there is one.
- */
-const getRootPackageJson = async (projectDir, rootDir) => {
-    if (existsSync(join(rootDir, 'package.json'))) {
-        return await readPackage({ cwd: rootDir, normalize: false });
-    }
-    const json = await findUp('package.json', { cwd: projectDir, stopAt: rootDir });
-    if (json) {
-        return await readPackage({ cwd: dirname(json), normalize: false });
-    }
-    return {};
-};
-export const getContext = async (config = {}) => {
-    const { projectDir = cwd(), rootDir = '' } = config;
-    // Get the absolute dirs for both project and root
-    // We resolve the projectDir from the rootDir
-    const absoluteProjectDir = resolve(rootDir, projectDir);
-    // If a relative absolute path is given we rely on cwd
-    const absoluteRootDir = rootDir ? resolve(cwd(), rootDir) : undefined;
-    // We only pass through the root dir if it was provided and is actually different
-    // from the project dir
-    const validRootDir = absoluteRootDir && absoluteRootDir !== absoluteProjectDir ? absoluteRootDir : undefined;
-    // If rootDir equals projectDir we'll be getting the projectDir package.json
-    // Later on if we also need the projectDir package.json we can check for it
-    // and only perform one resolution
-    let rootPackageJson = {};
-    try {
-        rootPackageJson = await getRootPackageJson(absoluteProjectDir, validRootDir || absoluteProjectDir);
-    }
-    catch {
-        // gracefully handle un-parseable package.json files
-        //noop
-    }
-    return {
-        projectDir: absoluteProjectDir,
-        rootDir: validRootDir,
-        rootPackageJson,
-    };
-};

package/lib/detect-build-system.d.ts

@@ -1,5 +0,0 @@
-export type BuildSystem = {
-    name: string;
-    version?: string | undefined;
-};
-export declare const detectBuildSystems: (baseDir: string, rootDir?: string) => Promise<BuildSystem[]>;