@vercel/python-analysis 0.1.1

package/dist/manifest/requirements-txt-parser.js

@@ -0,0 +1,400 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var requirements_txt_parser_exports = {};
+__export(requirements_txt_parser_exports, {
+  convertRequirementsToPyprojectToml: () => convertRequirementsToPyprojectToml,
+  parseRequirementsFile: () => parseRequirementsFile
+});
+module.exports = __toCommonJS(requirements_txt_parser_exports);
+var import_node_path = require("node:path");
+var import_pip_requirements_js = require("pip-requirements-js");
+var import_pep508 = require("./pep508");
+const PRIMARY_INDEX_NAME = "primary";
+const EXTRA_INDEX_PREFIX = "extra-";
+function parseGitUrl(url) {
+  if (!url.startsWith("git+")) {
+    return null;
+  }
+  let remaining = url.slice(4);
+  let egg;
+  const fragmentIdx = remaining.indexOf("#");
+  if (fragmentIdx !== -1) {
+    const fragment = remaining.slice(fragmentIdx + 1);
+    remaining = remaining.slice(0, fragmentIdx);
+    for (const part of fragment.split("&")) {
+      const [key, value] = part.split("=");
+      if (key === "egg" && value) {
+        egg = value;
+      }
+    }
+  }
+  let ref;
+  const lastSlashIdx = remaining.lastIndexOf("/");
+  const atIdx = remaining.indexOf("@", lastSlashIdx > 0 ? lastSlashIdx : 0);
+  if (atIdx !== -1 && atIdx > remaining.indexOf("://")) {
+    ref = remaining.slice(atIdx + 1);
+    remaining = remaining.slice(0, atIdx);
+  }
+  return {
+    url: remaining,
+    ref,
+    egg
+  };
+}
+function isGitUrl(url) {
+  return url.startsWith("git+");
+}
+function extractPipArguments(fileContent) {
+  const options = {
+    requirementFiles: [],
+    constraintFiles: [],
+    extraIndexUrls: []
+  };
+  const lines = fileContent.split(/\r?\n/);
+  const cleanedLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      cleanedLines.push(line);
+      continue;
+    }
+    let fullLine = trimmed;
+    let linesConsumed = 0;
+    while (fullLine.endsWith("\\") && i + linesConsumed + 1 < lines.length) {
+      linesConsumed++;
+      fullLine = fullLine.slice(0, -1) + lines[i + linesConsumed].trim();
+    }
+    const extracted = tryExtractPipArgument(fullLine, options);
+    if (extracted) {
+      i += linesConsumed;
+    } else {
+      const strippedLine = stripInlineHashes(fullLine);
+      if (strippedLine !== fullLine) {
+        cleanedLines.push(strippedLine);
+      } else {
+        cleanedLines.push(line);
+        for (let j = 1; j <= linesConsumed; j++) {
+          cleanedLines.push(lines[i + j]);
+        }
+      }
+      i += linesConsumed;
+    }
+  }
+  return {
+    cleanedContent: cleanedLines.join("\n"),
+    options
+  };
+}
+function tryExtractPipArgument(line, options) {
+  if (line.startsWith("--requirement")) {
+    const path = extractArgValue(line, "--requirement");
+    if (path) {
+      options.requirementFiles.push(path);
+      return true;
+    }
+  }
+  if (line.startsWith("--constraint")) {
+    const path = extractArgValue(line, "--constraint");
+    if (path) {
+      options.constraintFiles.push(path);
+      return true;
+    }
+  }
+  if (line.startsWith("--index-url")) {
+    const url = extractArgValue(line, "--index-url");
+    if (url) {
+      options.indexUrl = url;
+      return true;
+    }
+  }
+  if (line.startsWith("-i ") || line === "-i") {
+    const match = line.match(/^-i\s+(\S+)/);
+    if (match) {
+      options.indexUrl = match[1];
+      return true;
+    }
+  }
+  if (line.startsWith("--extra-index-url")) {
+    const url = extractArgValue(line, "--extra-index-url");
+    if (url) {
+      options.extraIndexUrls.push(url);
+      return true;
+    }
+  }
+  return false;
+}
+function stripInlineHashes(line) {
+  return line.replace(/\s+--hash=\S+/g, "").trim();
+}
+function extractInlineHashes(line) {
+  const hashes = [];
+  const hashRegex = /--hash=(\S+)/g;
+  let match;
+  while ((match = hashRegex.exec(line)) != null) {
+    hashes.push(match[1]);
+  }
+  return hashes;
+}
+function extractArgValue(line, option) {
+  if (line.startsWith(`${option}=`)) {
+    const value = line.slice(option.length + 1).trim();
+    return value || null;
+  }
+  if (line.startsWith(`${option} `) || line.startsWith(`${option}	`)) {
+    const value = line.slice(option.length).trim();
+    return value || null;
+  }
+  return null;
+}
+function convertRequirementsToPyprojectToml(fileContent, readFile) {
+  const pyproject = {};
+  const parsed = parseRequirementsFile(fileContent, readFile);
+  const deps = [];
+  const sources = {};
+  for (const req of parsed.requirements) {
+    deps.push((0, import_pep508.formatPep508)(req));
+    if (req.source) {
+      if (Object.prototype.hasOwnProperty.call(sources, req.name)) {
+        sources[req.name].push(req.source);
+      } else {
+        sources[req.name] = [req.source];
+      }
+    }
+  }
+  if (deps.length > 0) {
+    pyproject.project = {
+      dependencies: deps
+    };
+  }
+  const uv = {};
+  const indexes = buildIndexEntries(parsed.pipOptions);
+  if (indexes.length > 0) {
+    uv.index = indexes;
+  }
+  if (Object.keys(sources).length > 0) {
+    uv.sources = sources;
+  }
+  if (Object.keys(uv).length > 0) {
+    pyproject.tool = { uv };
+  }
+  return pyproject;
+}
+function buildIndexEntries(pipOptions) {
+  const indexes = [];
+  if (pipOptions.indexUrl) {
+    indexes.push({
+      name: PRIMARY_INDEX_NAME,
+      url: pipOptions.indexUrl,
+      default: true
+    });
+  }
+  for (let i = 0; i < pipOptions.extraIndexUrls.length; i++) {
+    indexes.push({
+      name: `${EXTRA_INDEX_PREFIX}${i + 1}`,
+      url: pipOptions.extraIndexUrls[i]
+    });
+  }
+  return indexes;
+}
+function parseRequirementsFile(fileContent, readFile) {
+  const visited = /* @__PURE__ */ new Set();
+  return parseRequirementsFileInternal(fileContent, readFile, visited);
+}
+function parseRequirementsFileInternal(fileContent, readFile, visited) {
+  const { cleanedContent, options } = extractPipArguments(fileContent);
+  const hashMap = buildHashMap(fileContent);
+  const requirements = (0, import_pip_requirements_js.parsePipRequirementsFile)(cleanedContent);
+  const normalized = [];
+  const mergedOptions = {
+    requirementFiles: [...options.requirementFiles],
+    constraintFiles: [...options.constraintFiles],
+    indexUrl: options.indexUrl,
+    extraIndexUrls: [...options.extraIndexUrls]
+  };
+  for (const req of requirements) {
+    if (req.type === "RequirementsFile") {
+      mergedOptions.requirementFiles.push(req.path);
+      continue;
+    }
+    if (req.type === "ConstraintsFile") {
+      mergedOptions.constraintFiles.push(req.path);
+      continue;
+    }
+    const norm = normalizeRequirement(req);
+    if (norm != null) {
+      const hashes = hashMap.get(norm.name.toLowerCase());
+      if (hashes && hashes.length > 0) {
+        norm.hashes = hashes;
+      }
+      normalized.push(norm);
+    }
+  }
+  if (readFile) {
+    for (const refPath of mergedOptions.requirementFiles) {
+      const refPathKey = (0, import_node_path.normalize)(refPath);
+      if (visited.has(refPathKey)) {
+        continue;
+      }
+      visited.add(refPathKey);
+      const refContent = readFile(refPath);
+      if (refContent != null) {
+        const refParsed = parseRequirementsFileInternal(
+          refContent,
+          readFile,
+          visited
+        );
+        const existingNames = new Set(
+          normalized.map((r) => r.name.toLowerCase())
+        );
+        for (const req of refParsed.requirements) {
+          if (!existingNames.has(req.name.toLowerCase())) {
+            normalized.push(req);
+            existingNames.add(req.name.toLowerCase());
+          }
+        }
+        if (refParsed.pipOptions.indexUrl) {
+          mergedOptions.indexUrl = refParsed.pipOptions.indexUrl;
+        }
+        for (const url of refParsed.pipOptions.extraIndexUrls) {
+          if (!mergedOptions.extraIndexUrls.includes(url)) {
+            mergedOptions.extraIndexUrls.push(url);
+          }
+        }
+        for (const constraintPath of refParsed.pipOptions.constraintFiles) {
+          if (!mergedOptions.constraintFiles.includes(constraintPath)) {
+            mergedOptions.constraintFiles.push(constraintPath);
+          }
+        }
+      }
+    }
+  }
+  return {
+    requirements: normalized,
+    pipOptions: mergedOptions
+  };
+}
+function buildHashMap(fileContent) {
+  const hashMap = /* @__PURE__ */ new Map();
+  const lines = fileContent.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i].trim();
+    if (line === "" || line.startsWith("#") || line.startsWith("-")) {
+      continue;
+    }
+    while (line.endsWith("\\") && i + 1 < lines.length) {
+      i++;
+      line = line.slice(0, -1) + lines[i].trim();
+    }
+    const hashes = extractInlineHashes(line);
+    if (hashes.length === 0) {
+      continue;
+    }
+    const packageMatch = line.match(/^([a-zA-Z0-9][-a-zA-Z0-9._]*)/);
+    if (packageMatch) {
+      const packageName = packageMatch[1].toLowerCase();
+      hashMap.set(packageName, hashes);
+    }
+  }
+  return hashMap;
+}
+function normalizeRequirement(req) {
+  if (req.type === "RequirementsFile" || req.type === "ConstraintsFile") {
+    return null;
+  }
+  if (req.type === "ProjectURL") {
+    return normalizeProjectURLRequirement(req);
+  }
+  if (req.type === "ProjectName") {
+    return normalizeProjectNameRequirement(req);
+  }
+  return null;
+}
+function normalizeProjectNameRequirement(req) {
+  const normalized = {
+    name: req.name
+  };
+  if (req.extras && req.extras.length > 0) {
+    normalized.extras = req.extras;
+  }
+  if (req.versionSpec && req.versionSpec.length > 0) {
+    normalized.version = req.versionSpec.map((spec) => `${spec.operator}${spec.version}`).join(",");
+  }
+  if (req.environmentMarkerTree) {
+    normalized.markers = formatEnvironmentMarkers(req.environmentMarkerTree);
+  }
+  return normalized;
+}
+function normalizeProjectURLRequirement(req) {
+  const normalized = {
+    name: req.name
+  };
+  if (req.extras && req.extras.length > 0) {
+    normalized.extras = req.extras;
+  }
+  if (req.environmentMarkerTree) {
+    normalized.markers = formatEnvironmentMarkers(req.environmentMarkerTree);
+  }
+  if (isGitUrl(req.url)) {
+    const parsed = parseGitUrl(req.url);
+    if (parsed) {
+      const source = {
+        git: parsed.url
+      };
+      if (parsed.ref) {
+        source.rev = parsed.ref;
+      }
+      if (parsed.editable) {
+        source.editable = true;
+      }
+      normalized.source = source;
+    }
+  }
+  normalized.url = req.url;
+  return normalized;
+}
+function formatEnvironmentMarkers(marker) {
+  if (isEnvironmentMarkerNode(marker)) {
+    const left = formatEnvironmentMarkers(marker.left);
+    const right = formatEnvironmentMarkers(marker.right);
+    return `(${left}) ${marker.operator} (${right})`;
+  }
+  const leaf = marker;
+  const leftStr = formatMarkerValue(leaf.left);
+  const rightStr = formatMarkerValue(leaf.right);
+  return `${leftStr} ${leaf.operator} ${rightStr}`;
+}
+function isEnvironmentMarkerNode(marker) {
+  if (typeof marker !== "object" || marker == null) {
+    return false;
+  }
+  const op = marker.operator;
+  return op === "and" || op === "or";
+}
+function formatMarkerValue(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value;
+  }
+  return value;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertRequirementsToPyprojectToml,
+  parseRequirementsFile
+});

package/dist/manifest/uv-config/schema.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Zod schemas for uv configuration types.
+ *
+ * Types are defined in types.ts (source of truth).
+ * Schemas are generated by ts-to-zod and re-exported here with proper typing.
+ *
+ * @module uv-config/schema
+ */
+import type { z } from 'zod';
+import type { UvConfig, UvConfigWorkspace, UvIndexEntry } from './types';
+/**
+ * Schema for uv workspace configuration.
+ */
+export declare const UvConfigWorkspaceSchema: z.ZodType<UvConfigWorkspace, z.ZodTypeDef, UvConfigWorkspace>;
+/**
+ * Schema for uv index entry configuration.
+ */
+export declare const UvIndexEntrySchema: z.ZodType<UvIndexEntry, z.ZodTypeDef, UvIndexEntry>;
+/**
+ * Schema for [tool.uv] section in pyproject.toml or uv.toml.
+ */
+export declare const UvConfigSchema: z.ZodType<UvConfig, z.ZodTypeDef, UvConfig>;

package/dist/manifest/uv-config/schema.js

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schema_exports = {};
+__export(schema_exports, {
+  UvConfigSchema: () => UvConfigSchema,
+  UvConfigWorkspaceSchema: () => UvConfigWorkspaceSchema,
+  UvIndexEntrySchema: () => UvIndexEntrySchema
+});
+module.exports = __toCommonJS(schema_exports);
+var import_schema = require("./schema.zod");
+const UvConfigWorkspaceSchema = import_schema.uvConfigWorkspaceSchema.passthrough();
+const UvIndexEntrySchema = import_schema.uvIndexEntrySchema.passthrough();
+const UvConfigSchema = import_schema.uvConfigSchema.passthrough();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UvConfigSchema,
+  UvConfigWorkspaceSchema,
+  UvIndexEntrySchema
+});

package/dist/manifest/uv-config/schema.zod.d.ts

@@ -0,0 +1,140 @@
+import { z } from 'zod';
+export declare const uvConfigWorkspaceSchema: z.ZodObject<{
+    members: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    members?: string[] | undefined;
+    exclude?: string[] | undefined;
+}, {
+    members?: string[] | undefined;
+    exclude?: string[] | undefined;
+}>;
+export declare const uvIndexEntrySchema: z.ZodObject<{
+    name: z.ZodString;
+    url: z.ZodString;
+    default: z.ZodOptional<z.ZodBoolean>;
+    explicit: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    url: string;
+    default?: boolean | undefined;
+    explicit?: boolean | undefined;
+}, {
+    name: string;
+    url: string;
+    default?: boolean | undefined;
+    explicit?: boolean | undefined;
+}>;
+export declare const uvConfigSchema: z.ZodObject<{
+    sources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+        index: z.ZodOptional<z.ZodString>;
+        git: z.ZodOptional<z.ZodString>;
+        rev: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+        editable: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        index?: string | undefined;
+        git?: string | undefined;
+        rev?: string | undefined;
+        path?: string | undefined;
+        editable?: boolean | undefined;
+    }, {
+        index?: string | undefined;
+        git?: string | undefined;
+        rev?: string | undefined;
+        path?: string | undefined;
+        editable?: boolean | undefined;
+    }>, z.ZodArray<z.ZodObject<{
+        index: z.ZodOptional<z.ZodString>;
+        git: z.ZodOptional<z.ZodString>;
+        rev: z.ZodOptional<z.ZodString>;
+        path: z.ZodOptional<z.ZodString>;
+        editable: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        index?: string | undefined;
+        git?: string | undefined;
+        rev?: string | undefined;
+        path?: string | undefined;
+        editable?: boolean | undefined;
+    }, {
+        index?: string | undefined;
+        git?: string | undefined;
+        rev?: string | undefined;
+        path?: string | undefined;
+        editable?: boolean | undefined;
+    }>, "many">]>>>;
+    index: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodString;
+        default: z.ZodOptional<z.ZodBoolean>;
+        explicit: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        url: string;
+        default?: boolean | undefined;
+        explicit?: boolean | undefined;
+    }, {
+        name: string;
+        url: string;
+        default?: boolean | undefined;
+        explicit?: boolean | undefined;
+    }>, "many">>;
+    workspace: z.ZodOptional<z.ZodObject<{
+        members: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        members?: string[] | undefined;
+        exclude?: string[] | undefined;
+    }, {
+        members?: string[] | undefined;
+        exclude?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    sources?: Record<string, {
+        index?: string | undefined;
+        git?: string | undefined;
+        rev?: string | undefined;
+        path?: string | undefined;
+        editable?: boolean | undefined;
+    } | {
+        index?: string | undefined;
+        git?: string | undefined;
+        rev?: string | undefined;
+        path?: string | undefined;
+        editable?: boolean | undefined;
+    }[]> | undefined;
+    index?: {
+        name: string;
+        url: string;
+        default?: boolean | undefined;
+        explicit?: boolean | undefined;
+    }[] | undefined;
+    workspace?: {
+        members?: string[] | undefined;
+        exclude?: string[] | undefined;
+    } | undefined;
+}, {
+    sources?: Record<string, {
+        index?: string | undefined;
+        git?: string | undefined;
+        rev?: string | undefined;
+        path?: string | undefined;
+        editable?: boolean | undefined;
+    } | {
+        index?: string | undefined;
+        git?: string | undefined;
+        rev?: string | undefined;
+        path?: string | undefined;
+        editable?: boolean | undefined;
+    }[]> | undefined;
+    index?: {
+        name: string;
+        url: string;
+        default?: boolean | undefined;
+        explicit?: boolean | undefined;
+    }[] | undefined;
+    workspace?: {
+        members?: string[] | undefined;
+        exclude?: string[] | undefined;
+    } | undefined;
+}>;

package/dist/manifest/uv-config/schema.zod.js

@@ -0,0 +1,48 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schema_zod_exports = {};
+__export(schema_zod_exports, {
+  uvConfigSchema: () => uvConfigSchema,
+  uvConfigWorkspaceSchema: () => uvConfigWorkspaceSchema,
+  uvIndexEntrySchema: () => uvIndexEntrySchema
+});
+module.exports = __toCommonJS(schema_zod_exports);
+var import_zod = require("zod");
+var import_schema = require("./../requirement/schema.zod");
+const uvConfigWorkspaceSchema = import_zod.z.object({
+  members: import_zod.z.array(import_zod.z.string()).optional(),
+  exclude: import_zod.z.array(import_zod.z.string()).optional()
+});
+const uvIndexEntrySchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  url: import_zod.z.string(),
+  default: import_zod.z.boolean().optional(),
+  explicit: import_zod.z.boolean().optional()
+});
+const uvConfigSchema = import_zod.z.object({
+  sources: import_zod.z.record(import_zod.z.union([import_schema.dependencySourceSchema, import_zod.z.array(import_schema.dependencySourceSchema)])).optional(),
+  index: import_zod.z.array(uvIndexEntrySchema).optional(),
+  workspace: uvConfigWorkspaceSchema.optional()
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  uvConfigSchema,
+  uvConfigWorkspaceSchema,
+  uvIndexEntrySchema
+});

package/dist/manifest/uv-config/types.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Pure TypeScript interface definitions for uv configuration types.
+ *
+ * These interfaces serve as the source of truth for types.
+ * Zod schemas are generated from these using ts-to-zod.
+ *
+ * @module uv-config/types
+ */
+import type { DependencySource } from '../requirement/types';
+/**
+ * uv workspace configuration.
+ * @passthrough
+ */
+export interface UvConfigWorkspace {
+    members?: string[];
+    exclude?: string[];
+}
+/**
+ * uv index entry configuration.
+ * @passthrough
+ */
+export interface UvIndexEntry {
+    name: string;
+    url: string;
+    /** Mark this index as the default (replaces PyPI) */
+    default?: boolean;
+    /** Mark this index as explicit (must be explicitly referenced per-package) */
+    explicit?: boolean;
+}
+/**
+ * [tool.uv] section in pyproject.toml or uv.toml.
+ * @passthrough
+ */
+export interface UvConfig {
+    /**
+     * Dependency sources mapping package names to their source configurations.
+     * Used for git, path, and custom index sources.
+     */
+    sources?: Record<string, DependencySource | DependencySource[]>;
+    /**
+     * Custom package indexes.
+     */
+    index?: UvIndexEntry[];
+    /**
+     * Workspace configuration.
+     */
+    workspace?: UvConfigWorkspace;
+}