neon 2.1.2 → 2.29.0

package/dist/commands/schema_diff.js

@@ -0,0 +1,151 @@
+import chalk from "chalk";
+import { createPatch } from "diff";
+import { sendError } from "../analytics.js";
+import { isNeonApiError, messageFromBody } from "../api.js";
+import { log } from "../log.js";
+import { branchIdFromProps } from "../utils/enrichers.js";
+import { parsePointInTime, } from "../utils/point_in_time.js";
+import { writer } from "../writer.js";
+const COLORS = {
+    added: chalk.green,
+    removed: chalk.red,
+    header: chalk.yellow,
+    section: chalk.magenta,
+};
+export const schemaDiff = async (props) => {
+    props.branch = props.baseBranch || props.branch;
+    const baseBranch = await branchIdFromProps(props);
+    let pointInTime = await parsePointInTime({
+        pointInTime: props.compareSource,
+        targetBranchId: baseBranch,
+        projectId: props.projectId,
+        api: props.apiClient,
+    });
+    // Swap base and compare points if comparing with parent branch
+    const comparingWithParent = props.compareSource.startsWith("^parent");
+    let baseBranchPoint = {
+        branchId: baseBranch,
+        tag: "head",
+    };
+    [baseBranchPoint, pointInTime] = comparingWithParent
+        ? [pointInTime, baseBranchPoint]
+        : [baseBranchPoint, pointInTime];
+    const baseDatabases = await fetchDatabases(baseBranch, props);
+    if (props.database) {
+        const database = baseDatabases.find((db) => db.name === props.database);
+        if (!database) {
+            throw new Error(`Database ${props.database} does not exist in base branch ${baseBranch}`);
+        }
+        const patch = await createSchemaDiff(baseBranchPoint, pointInTime, database, props);
+        writer(props).text(colorize(patch));
+        return;
+    }
+    await Promise.all(baseDatabases.map(async (database) => {
+        const patch = await createSchemaDiff(baseBranchPoint, pointInTime, database, props);
+        writer(props).text(colorize(patch));
+    }));
+};
+const fetchDatabases = async (branch, props) => {
+    return props.apiClient
+        .listProjectBranchDatabases(props.projectId, branch)
+        .then((response) => response.data.databases);
+};
+const createSchemaDiff = async (baseBranch, pointInTime, database, props) => {
+    const [baseSchema, compareSchema] = await Promise.all([
+        fetchSchema(baseBranch, database, props),
+        fetchSchema(pointInTime, database, props),
+    ]);
+    return createPatch(`Database: ${database.name}`, baseSchema, compareSchema, generateHeader(baseBranch), generateHeader(pointInTime));
+};
+const fetchSchema = async (pointInTime, database, props) => {
+    try {
+        const response = await props.apiClient.getProjectBranchSchema({
+            projectId: props.projectId,
+            branchId: pointInTime.branchId,
+            db_name: database.name,
+            ...pointInTimeParams(pointInTime),
+        });
+        return response.data.sql ?? "";
+    }
+    catch (error) {
+        if (isNeonApiError(error)) {
+            sendError(error, "API_ERROR");
+            throw new Error(messageFromBody(error.data) ??
+                `Error while fetching schema for branch ${pointInTime.branchId}`);
+        }
+        throw error;
+    }
+};
+const colorize = (patch) => {
+    return patch
+        .replace(/^([^\n]+)\n([^\n]+)\n/m, "") // Remove first two lines
+        .replace(/^-.*/gm, colorizer("removed"))
+        .replace(/^\+.*/gm, colorizer("added"))
+        .replace(/^@@.+@@.*/gm, colorizer("section"));
+};
+const colorizer = (colorId) => {
+    const color = COLORS[colorId];
+    return (line) => color(line);
+};
+const pointInTimeParams = (pointInTime) => {
+    switch (pointInTime.tag) {
+        case "timestamp":
+            return {
+                timestamp: pointInTime.timestamp,
+            };
+        case "lsn":
+            return {
+                lsn: pointInTime.lsn ?? undefined,
+            };
+        default:
+            return {};
+    }
+};
+const generateHeader = (pointInTime) => {
+    const header = `(Branch: ${pointInTime.branchId}`;
+    switch (pointInTime.tag) {
+        case "timestamp":
+            return `${header} at ${pointInTime.timestamp})`;
+        case "lsn":
+            return `${header} at ${pointInTime.lsn})`;
+        default:
+            return `${header})`;
+    }
+};
+/*
+  The command has two positional optional arguments - [base-branch] and [compare-source]
+  If only one argument is specified, we should consider it as `compare-source`
+    and `base-branch` will be either read from context or the default branch of project.
+  If no branches are specified, compare the context branch with its parent
+*/
+export const parseSchemaDiffParams = async (props) => {
+    if (!props.compareSource) {
+        if (props.baseBranch) {
+            props.compareSource = props.baseBranch;
+            props.baseBranch = props.branch;
+        }
+        else if (props.branch) {
+            const { data } = await props.apiClient.listProjectBranches({
+                projectId: props.projectId,
+            });
+            const contextBranch = data.branches.find((b) => b.id === props.branch || b.name === props.branch);
+            if (contextBranch?.parent_id == undefined) {
+                throw new Error(`No branch specified. Your context branch (${props.branch}) has no parent, so no comparison is possible.`);
+            }
+            log.info(`No branches specified. Comparing your context branch '${props.branch}' with its parent`);
+            props.compareSource = "^parent";
+        }
+        else {
+            const { data } = await props.apiClient.listProjectBranches({
+                projectId: props.projectId,
+            });
+            const defaultBranch = data.branches.find((b) => b.default);
+            if (defaultBranch?.parent_id == undefined) {
+                throw new Error("No branch specified. Include a base branch or add a set-context branch to continue. Your default branch has no parent, so no comparison is possible.");
+            }
+            log.info(`No branches specified. Comparing default branch with its parent`);
+            props.compareSource = "^parent";
+        }
+    }
+    return props;
+};

package/dist/commands/set_context.js

@@ -0,0 +1,29 @@
+import { applyContext } from "../context.js";
+import { log } from "../log.js";
+export const command = "set-context";
+export const describe = "Deprecated: use `neonctl link`. Set the .neon context (raw write).";
+export const builder = (argv) => argv.usage("$0 set-context [options]").options({
+    "project-id": {
+        describe: "Project ID",
+        type: "string",
+    },
+    "org-id": {
+        describe: "Organization ID",
+        type: "string",
+    },
+    "branch-id": {
+        describe: "Branch ID",
+        type: "string",
+    },
+});
+export const handler = (props) => {
+    log.warning("`neonctl set-context` is deprecated and will be removed in a future release. " +
+        "Use `neonctl link` instead — it verifies inputs and infers the org for you " +
+        "(or `neonctl link --no-checks` for the same write-without-checks behavior).");
+    const context = {
+        projectId: props.projectId,
+        orgId: props.orgId,
+        branchId: props.branchId,
+    };
+    applyContext(props.contextFile, context);
+};

package/dist/commands/status.js

@@ -0,0 +1,40 @@
+import { fillSingleProject } from "../utils/enrichers.js";
+import { status } from "./config.js";
+/**
+ * `neon status` is a top-level alias for `neon config status` — the most-reached-for
+ * config subcommand. It mirrors that command's options (including `--current-branch`,
+ * the offline branch probe) and delegates to the same `status` handler.
+ *
+ * Because it has a handler but no subcommands, `status` must also be listed in
+ * `NO_SUBCOMMANDS_VERBS` (see index.ts) so the help-fallback middleware doesn't
+ * intercept a bare `neon status`.
+ */
+export const command = "status";
+export const describe = "Show the branch's live Neon state (alias of `config status`)";
+export const builder = (argv) => argv
+    .usage("$0 status [options]")
+    .options({
+    "project-id": {
+        describe: "Project ID",
+        type: "string",
+    },
+    branch: {
+        describe: "Branch ID or name",
+        type: "string",
+    },
+    "config-json": {
+        describe: "Print only the branch's live config as neon.ts-shaped JSON " +
+            "(services + branch tuning + preview), to stdout. Useful for " +
+            "scripting or copying into a neon.ts.",
+        type: "boolean",
+        default: false,
+    },
+    "current-branch": {
+        describe: "Print only the linked branch name from the local .neon file " +
+            "(no network). Exits non-zero when no branch is pinned.",
+        type: "boolean",
+        default: false,
+    },
+})
+    .middleware(fillSingleProject);
+export const handler = (args) => status(args);

package/dist/commands/user.js

@@ -0,0 +1,15 @@
+import { writer } from "../writer.js";
+export const command = "me";
+export const describe = "Show current user";
+export const builder = (yargs) => yargs.option("context-file", {
+    hidden: true,
+});
+export const handler = async (args) => {
+    await me(args);
+};
+const me = async (props) => {
+    const { data } = await props.apiClient.getCurrentUserInfo();
+    writer(props).end(data, {
+        fields: ["login", "email", "name", "projects_limit"],
+    });
+};

package/dist/commands/vpc_endpoints.js

@@ -0,0 +1,134 @@
+import { log } from "../log.js";
+import { fillSingleOrg, fillSingleProject } from "../utils/enrichers.js";
+import { writer } from "../writer.js";
+import { REGIONS } from "./projects.js";
+const VPC_ENDPOINT_FIELDS = ["vpc_endpoint_id", "label"];
+const VPC_ENDPOINT_DETAILS_FIELDS = [
+    "vpc_endpoint_id",
+    "label",
+    "state",
+    "num_restricted_projects",
+    "example_restricted_projects",
+];
+export const command = "vpc";
+export const describe = "Manage VPC endpoints and project VPC restrictions";
+export const builder = (argv) => {
+    return argv
+        .usage("$0 vpc <sub-command> [options]")
+        .command("endpoint", "Manage VPC endpoints.\n" +
+        "See: https://neon.tech/docs/guides/neon-private-networking\n" +
+        "After adding an endpoint to an organization, client connections will be accepted\n" +
+        "from the corresponding VPC for all projects in the organization, unless overridden\n" +
+        "by a project-level VPC endpoint restriction.", (yargs) => {
+        return yargs
+            .options({
+            "org-id": {
+                describe: "Organization ID",
+                type: "string",
+            },
+            "region-id": {
+                describe: `The region ID. Possible values: ${REGIONS.join(", ")}`,
+                type: "string",
+                demandOption: true,
+            },
+        })
+            .middleware(fillSingleOrg)
+            .command("list", "List configured VPC endpoints for this organization.", (yargs) => yargs, async (args) => {
+            await listOrg(args);
+        })
+            .command({
+            command: "assign <id>",
+            aliases: ["update <id>", "add <id>"],
+            describe: "Add or update a VPC endpoint for this organization.\n" +
+                "Note: Azure regions are not yet supported.",
+            builder: (yargs) => yargs.options({
+                label: {
+                    describe: "An optional descriptive label for the VPC endpoint",
+                    type: "string",
+                },
+            }),
+            handler: async (args) => {
+                await assignOrg(args);
+            },
+        })
+            .command("remove <id>", "Remove a VPC endpoint from this organization.", (yargs) => yargs, async (args) => {
+            await removeOrg(args);
+        })
+            .command("status <id>", "Get the status of a VPC endpoint for this organization.", (yargs) => yargs, async (args) => {
+            await statusOrg(args);
+        });
+    })
+        .command("project", "Manage project-level VPC endpoint restrictions.\n" +
+        "By default, connections are accepted from any VPC configured at the organization level.\n" +
+        "A project-level VPC endpoint restriction can be used to restrict connections to a specific VPC.", (yargs) => {
+        return yargs
+            .options({
+            "project-id": {
+                describe: "Project ID",
+                type: "string",
+            },
+        })
+            .middleware(fillSingleProject)
+            .command("list", "List VPC endpoint restrictions for this project.", (yargs) => yargs, async (args) => {
+            await listProject(args);
+        })
+            .command({
+            command: "restrict <id>",
+            aliases: ["update <id>"],
+            describe: "Configure or update a VPC endpoint restriction for this project.",
+            builder: (yargs) => yargs.options({
+                label: {
+                    describe: "An optional descriptive label for the VPC endpoint restriction",
+                    type: "string",
+                },
+            }),
+            handler: async (args) => {
+                await assignProject(args);
+            },
+        })
+            .command("remove <id>", "Remove a VPC endpoint restriction from this project.", (yargs) => yargs, async (args) => {
+            await removeProject(args);
+        });
+    });
+};
+const listOrg = async (props) => {
+    const { data } = await props.apiClient.listOrganizationVpcEndpoints(props.orgId, props.regionId);
+    writer(props).end(data.endpoints, {
+        fields: VPC_ENDPOINT_FIELDS,
+    });
+};
+const assignOrg = async (props) => {
+    const vpcEndpointAssignment = {
+        label: props.label || "",
+    };
+    const { data } = await props.apiClient.assignOrganizationVpcEndpoint(props.orgId, props.regionId, props.id, vpcEndpointAssignment);
+    writer(props).end(data, { fields: [] });
+    if (props.regionId.startsWith("azure")) {
+        log.info("VPC endpoint configuration is not supported for Azure regions");
+    }
+};
+const removeOrg = async (props) => {
+    const { data } = await props.apiClient.deleteOrganizationVpcEndpoint(props.orgId, props.regionId, props.id);
+    writer(props).end(data, { fields: [] });
+};
+const statusOrg = async (props) => {
+    const { data } = await props.apiClient.getOrganizationVpcEndpointDetails(props.orgId, props.regionId, props.id);
+    writer(props).end(data, { fields: VPC_ENDPOINT_DETAILS_FIELDS });
+};
+const listProject = async (props) => {
+    const { data } = await props.apiClient.listProjectVpcEndpoints(props.projectId);
+    writer(props).end(data.endpoints, {
+        fields: VPC_ENDPOINT_FIELDS,
+    });
+};
+const assignProject = async (props) => {
+    const vpcEndpointAssignment = {
+        label: props.label || "",
+    };
+    const { data } = await props.apiClient.assignProjectVpcEndpoint(props.projectId, props.id, vpcEndpointAssignment);
+    writer(props).end(data, { fields: [] });
+};
+const removeProject = async (props) => {
+    const { data } = await props.apiClient.deleteProjectVpcEndpoint(props.projectId, props.id);
+    writer(props).end(data, { fields: [] });
+};

package/dist/config.js

@@ -0,0 +1,11 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { isCi } from "./env.js";
+export const CREDENTIALS_FILE = "credentials.json";
+export const defaultDir = join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "neonctl");
+export const ensureConfigDir = ({ "config-dir": configDir, "force-auth": forceAuth, }) => {
+    if (!existsSync(configDir) && (!isCi() || forceAuth)) {
+        mkdirSync(configDir, { recursive: true });
+    }
+};

package/dist/config_format.js

@@ -0,0 +1,72 @@
+/**
+ * Render a TTL in whole seconds back to the canonical `neon.ts` duration string (e.g.
+ * `604800` -> `"7d"`), falling back to seconds when no clean unit boundary matches. Mirrors
+ * the formatter `@neon/config` uses when it emits a TTL, so `config status` shows
+ * the same value a user would write in `neon.ts`.
+ */
+export const formatDurationSeconds = (totalSeconds) => {
+    const units = [
+        ["w", 7 * 24 * 60 * 60],
+        ["d", 24 * 60 * 60],
+        ["h", 60 * 60],
+        ["m", 60],
+    ];
+    for (const [unit, perUnit] of units) {
+        if (totalSeconds % perUnit === 0)
+            return `${totalSeconds / perUnit}${unit}`;
+    }
+    return `${totalSeconds}s`;
+};
+/**
+ * Project a resolved branch config (plus the separately-pulled preview state, since
+ * functions/buckets don't live on the closure) into a {@link NeonConfigView}.
+ *
+ * - Service toggles are surfaced as `true` only when enabled (disabled is the absence of
+ *   the key, exactly as in `neon.ts`).
+ * - `ttlSeconds` is rendered back to a duration string (`7d`).
+ * - The `branch` section is the JSON-able part of what would otherwise be the `branch`
+ *   closure: `parent` / `ttl` / `protected` / `postgres.computeSettings`.
+ * - `branch` and `preview` are omitted entirely when they would be empty.
+ */
+export const toNeonConfigView = (resolved, preview) => {
+    const view = {};
+    if (resolved.authEnabled)
+        view.auth = true;
+    if (resolved.dataApiEnabled)
+        view.dataApi = true;
+    const previewView = toPreviewView(preview);
+    if (previewView)
+        view.preview = previewView;
+    const branch = {};
+    if (resolved.parent !== undefined)
+        branch.parent = resolved.parent;
+    if (resolved.ttlSeconds !== undefined)
+        branch.ttl = formatDurationSeconds(resolved.ttlSeconds);
+    if (resolved.protected !== undefined)
+        branch.protected = resolved.protected;
+    if (resolved.postgres?.computeSettings)
+        branch.postgres = resolved.postgres;
+    if (Object.keys(branch).length > 0)
+        view.branch = branch;
+    return view;
+};
+const toPreviewView = (preview) => {
+    if (!preview)
+        return undefined;
+    const out = {};
+    if (preview.functions.length > 0) {
+        out.functions = Object.fromEntries(preview.functions.map((fn) => [fn.slug, { name: fn.name }]));
+    }
+    if (preview.buckets.length > 0) {
+        out.buckets = Object.fromEntries(preview.buckets.map((b) => [b.name, { access: b.access }]));
+    }
+    if (preview.credentials.length > 0) {
+        out.credentials = preview.credentials.map((c) => ({
+            id: c.tokenIdShort,
+            ...(c.name ? { name: c.name } : {}),
+            scopes: c.scopes,
+            ...(c.lastUsedAt ? { lastUsedAt: c.lastUsedAt } : {}),
+        }));
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+};

package/dist/context.js

@@ -0,0 +1,177 @@
+import { accessSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, normalize, resolve } from "node:path";
+import { log } from "./log.js";
+/**
+ * The branch pinned in a context, reading the current `branch` field and
+ * falling back to the legacy `branchId` so pre-migration `.neon` files keep
+ * working.
+ */
+export const contextBranch = (context) => context.branch ?? context.branchId;
+/**
+ * True when the invocation is the offline "current branch" probe:
+ * `(config) status --current-branch`. This mode only reads the pinned branch
+ * from the local `.neon` file (for shell prompts like starship), so it MUST
+ * NOT touch the network — several middlewares (auth, analytics, single-project
+ * resolution) consult this to early-return and skip their API calls / login.
+ *
+ * Gated on the exact command as well as the flag so an accidental
+ * `--current-branch` on an unrelated command (e.g. `config plan`, where the flag
+ * is undefined but non-strict yargs still parses it) can't silently skip
+ * auth/analytics. The probe is only `status` (the top-level alias) or
+ * `config status` (`_ = ['config', 'status']`).
+ */
+export const isCurrentBranchProbe = (args) => args.currentBranch === true &&
+    (args._[0] === "status" ||
+        (args._[0] === "config" && args._[1] === "status"));
+/**
+ * `config init` only scaffolds a local `neon.ts` and installs npm packages — it
+ * never calls the Neon API. Gated on the exact command path so the global auth
+ * middleware and the single-project resolver can skip it (it runs with no API
+ * client), mirroring {@link isCurrentBranchProbe}.
+ */
+export const isConfigInit = (args) => args._[0] === "config" && args._[1] === "init";
+const CONTEXT_FILE = ".neon";
+const GITIGNORE_FILE = ".gitignore";
+const wrapWithContextFile = (dir) => resolve(dir, CONTEXT_FILE);
+/**
+ * Resolve the default `.neon` path for the current working directory.
+ *
+ * Walks UP from `cwd` looking ONLY for an already-existing `.neon` file so
+ * commands run from a sub-directory of a linked project still pick up the
+ * project's context. If no `.neon` is found, the path defaults to
+ * `<cwd>/.neon`, which makes `neonctl link` and `neonctl set-context`
+ * predictable: they always write the context file into the directory they
+ * were invoked from.
+ *
+ * Historically the walk also considered `package.json` and `.git` as project
+ * markers, but that led to surprising behaviour when running `link` from a
+ * fresh sub-directory inside an unrelated repo (the new link would land in
+ * the parent repo's root instead of the cwd).
+ *
+ * `cwd` is overridable so tests can exercise the walk-up without mutating
+ * `process.cwd()` (which would race with other tests running in parallel).
+ */
+export const currentContextFile = (cwd = process.cwd()) => {
+    let currentDir = cwd;
+    const root = normalize("/");
+    const home = homedir();
+    while (currentDir !== root && currentDir !== home) {
+        try {
+            accessSync(resolve(currentDir, CONTEXT_FILE));
+            return wrapWithContextFile(currentDir);
+        }
+        catch {
+            // ignore
+        }
+        currentDir = resolve(currentDir, "..");
+    }
+    return wrapWithContextFile(cwd);
+};
+export const readContextFile = (file) => {
+    try {
+        return JSON.parse(readFileSync(file, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+};
+export const enrichFromContext = (args) => {
+    // `link` and the deprecated `set-context` manage the context file themselves
+    // and must see the raw flags rather than values pre-filled from an existing
+    // `.neon`, so skip enrichment for both.
+    if (args._[0] === "link" || args._[0] === "set-context") {
+        return;
+    }
+    const context = readContextFile(args.contextFile);
+    if (!args.orgId) {
+        args.orgId = context.orgId;
+    }
+    if (!args.projectId) {
+        args.projectId = context.projectId;
+    }
+    if (!args.branch &&
+        !args.id &&
+        !args.name &&
+        context.projectId === args.projectId) {
+        args.branch = contextBranch(context);
+    }
+};
+export const updateContextFile = (file, context) => {
+    writeFileSync(file, JSON.stringify(context, null, 2));
+};
+/**
+ * Shared primitive used by `link`, the deprecated `set-context`, and `checkout`
+ * to persist context. Mirrors the destructive write semantics of
+ * `updateContextFile` — any field not present in `context` is dropped from the
+ * file.
+ *
+ * `.gitignore` scaffolding only happens when the context file is being
+ * *created* (it didn't exist before this write). On updates to an existing
+ * `.neon` we never touch `.gitignore`, so a user who deliberately un-ignored
+ * the file (e.g. to commit shared context) won't have the entry re-added on
+ * every subsequent command.
+ */
+export const applyContext = (file, context) => {
+    const isNewFile = !existsSync(file);
+    updateContextFile(file, context);
+    if (isNewFile) {
+        ensureGitignored(file);
+    }
+};
+/**
+ * Low-level writer for callers that already hold the resolved identifiers and
+ * just need to record them — e.g. `init` or `projects create`, which create a
+ * project and want to link it without the resolution, verification, prompting,
+ * or env-pull that `link` performs.
+ *
+ * Unlike the loose {@link applyContext}, this enforces at the type level that
+ * `orgId` and `projectId` are present, so the `.neon` file never ends up with a
+ * dangling project that has no org. The branch stays optional. It writes through
+ * {@link applyContext}, so the same `.gitignore` scaffolding applies.
+ */
+export const setContext = (file, context) => {
+    applyContext(file, {
+        orgId: context.orgId,
+        projectId: context.projectId,
+        branch: context.branch,
+    });
+};
+/**
+ * Make sure the `.gitignore` next to `file` lists the file's basename
+ * (currently always `.neon`). Creates the `.gitignore` if it doesn't exist,
+ * or appends `.neon` if it's missing — never duplicates an existing entry.
+ *
+ * Best-effort: a failure here (e.g. read-only filesystem) is logged at debug
+ * level and swallowed; persisting the context file is the primary goal and
+ * must not be blocked by a `.gitignore` write error.
+ */
+export const ensureGitignored = (file) => {
+    try {
+        const dir = dirname(file);
+        const entry = basenameOf(file);
+        const gitignorePath = resolve(dir, GITIGNORE_FILE);
+        if (!existsSync(gitignorePath)) {
+            writeFileSync(gitignorePath, `${entry}\n`);
+            return;
+        }
+        const current = readFileSync(gitignorePath, "utf-8");
+        if (hasGitignoreEntry(current, entry)) {
+            return;
+        }
+        const needsLeadingNewline = current.length > 0 && !current.endsWith("\n");
+        const addition = `${needsLeadingNewline ? "\n" : ""}${entry}\n`;
+        writeFileSync(gitignorePath, current + addition);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log.debug("Failed to update .gitignore next to %s: %s", file, message);
+    }
+};
+const basenameOf = (file) => {
+    const parts = file.split(/[\\/]/);
+    return parts[parts.length - 1] || CONTEXT_FILE;
+};
+const hasGitignoreEntry = (content, entry) => {
+    return content.split(/\r?\n/).some((line) => line.trim() === entry);
+};