@vercel/python-analysis 0.1.1

package/dist/manifest/pipfile/schema.zod.js

@@ -0,0 +1,97 @@
+"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, {
+  pipfileDependencyDetailSchema: () => pipfileDependencyDetailSchema,
+  pipfileDependencySchema: () => pipfileDependencySchema,
+  pipfileLikeSchema: () => pipfileLikeSchema,
+  pipfileLockLikeSchema: () => pipfileLockLikeSchema,
+  pipfileLockMetaSchema: () => pipfileLockMetaSchema,
+  pipfileSourceSchema: () => pipfileSourceSchema
+});
+module.exports = __toCommonJS(schema_zod_exports);
+var import_zod = require("zod");
+const pipfileDependencyDetailSchema = import_zod.z.object({
+  version: import_zod.z.string().optional(),
+  hashes: import_zod.z.array(import_zod.z.string()).optional(),
+  extras: import_zod.z.union([import_zod.z.array(import_zod.z.string()), import_zod.z.string()]).optional(),
+  markers: import_zod.z.string().optional(),
+  index: import_zod.z.string().optional(),
+  git: import_zod.z.string().optional(),
+  ref: import_zod.z.string().optional(),
+  editable: import_zod.z.boolean().optional(),
+  path: import_zod.z.string().optional()
+});
+const pipfileDependencySchema = import_zod.z.union([
+  import_zod.z.string(),
+  pipfileDependencyDetailSchema
+]);
+const pipfileSourceSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  url: import_zod.z.string(),
+  verify_ssl: import_zod.z.boolean().optional()
+});
+const pipfileLikeSchema = import_zod.z.record(
+  import_zod.z.union([
+    import_zod.z.record(pipfileDependencySchema),
+    import_zod.z.array(pipfileSourceSchema),
+    import_zod.z.record(import_zod.z.string()),
+    import_zod.z.undefined()
+  ])
+).and(
+  import_zod.z.object({
+    packages: import_zod.z.record(pipfileDependencySchema).optional(),
+    "dev-packages": import_zod.z.record(pipfileDependencySchema).optional(),
+    source: import_zod.z.array(pipfileSourceSchema).optional(),
+    scripts: import_zod.z.record(import_zod.z.string()).optional()
+  })
+);
+const pipfileLockMetaSchema = import_zod.z.object({
+  hash: import_zod.z.object({
+    sha256: import_zod.z.string().optional()
+  }).optional(),
+  "pipfile-spec": import_zod.z.number().optional(),
+  requires: import_zod.z.object({
+    python_version: import_zod.z.string().optional(),
+    python_full_version: import_zod.z.string().optional()
+  }).optional(),
+  sources: import_zod.z.array(pipfileSourceSchema).optional()
+});
+const pipfileLockLikeSchema = import_zod.z.record(
+  import_zod.z.union([
+    pipfileLockMetaSchema,
+    import_zod.z.record(pipfileDependencyDetailSchema),
+    import_zod.z.undefined()
+  ])
+).and(
+  import_zod.z.object({
+    _meta: pipfileLockMetaSchema.optional(),
+    default: import_zod.z.record(pipfileDependencyDetailSchema).optional(),
+    develop: import_zod.z.record(pipfileDependencyDetailSchema).optional()
+  })
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pipfileDependencyDetailSchema,
+  pipfileDependencySchema,
+  pipfileLikeSchema,
+  pipfileLockLikeSchema,
+  pipfileLockMetaSchema,
+  pipfileSourceSchema
+});

package/dist/manifest/pipfile/types.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Pure TypeScript interface definitions for Pipfile and Pipfile.lock types.
+ *
+ * These interfaces serve as the source of truth for types.
+ * Zod schemas are generated from these using ts-to-zod.
+ *
+ * @module pipfile/types
+ */
+/**
+ * Pipfile dependency detail object.
+ * @passthrough
+ */
+export interface PipfileDependencyDetail {
+    version?: string;
+    hashes?: string[];
+    extras?: string[] | string;
+    markers?: string;
+    index?: string;
+    git?: string;
+    ref?: string;
+    editable?: boolean;
+    path?: string;
+}
+/**
+ * Pipfile dependency (string version specifier or detail object).
+ */
+export type PipfileDependency = string | PipfileDependencyDetail;
+/**
+ * Pipfile source configuration.
+ * @passthrough
+ */
+export interface PipfileSource {
+    name: string;
+    url: string;
+    verify_ssl?: boolean;
+}
+/**
+ * Pipfile configuration.
+ * @passthrough
+ */
+export interface PipfileLike {
+    packages?: Record<string, PipfileDependency>;
+    'dev-packages'?: Record<string, PipfileDependency>;
+    source?: PipfileSource[];
+    scripts?: Record<string, string>;
+    /** Allow additional category keys (custom dependency groups) */
+    [key: string]: Record<string, PipfileDependency> | PipfileSource[] | Record<string, string> | undefined;
+}
+/**
+ * Pipfile.lock _meta section.
+ * @passthrough
+ */
+export interface PipfileLockMeta {
+    hash?: {
+        sha256?: string;
+    };
+    'pipfile-spec'?: number;
+    requires?: {
+        python_version?: string;
+        python_full_version?: string;
+    };
+    sources?: PipfileSource[];
+}
+/**
+ * Pipfile.lock configuration.
+ *
+ * Note: This schema allows additional category keys (like custom dependency groups)
+ * which can contain package dictionaries.
+ * @passthrough
+ */
+export interface PipfileLockLike {
+    _meta?: PipfileLockMeta;
+    default?: Record<string, PipfileDependencyDetail>;
+    develop?: Record<string, PipfileDependencyDetail>;
+    /** Allow additional category keys (custom dependency groups) */
+    [key: string]: PipfileLockMeta | Record<string, PipfileDependencyDetail> | undefined;
+}

package/dist/manifest/pipfile/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/manifest/pipfile-parser.d.ts

@@ -0,0 +1,35 @@
+import type { PyProjectToml } from './pyproject/types';
+import type { PipfileLike, PipfileLockLike } from './pipfile/types';
+/**
+ * Migrate a parsed Pipfile to a pyproject.toml object suitable for uv.
+ *
+ * This creates a minimal pyproject:
+ *
+ * [project]
+ * dependencies = [...]
+ *
+ * [dependency-groups]
+ * dev = [...]
+ *
+ * [tool.uv.sources] + [[tool.uv.index]]
+ */
+export declare function convertPipfileToPyprojectToml(pipfile: PipfileLike): PyProjectToml;
+/**
+ * Migrate a parsed Pipfile.lock to a pyproject.toml object suitable for uv.
+ *
+ * Pipfile.lock uses different key names than Pipfile:
+ * - "default" instead of "packages"
+ * - "develop" instead of "dev-packages"
+ * - Custom categories use the same name in both files
+ *
+ * This creates a minimal pyproject:
+ *
+ * [project]
+ * dependencies = [...]
+ *
+ * [dependency-groups]
+ * dev = [...]
+ *
+ * [tool.uv.sources] + [[tool.uv.index]]
+ */
+export declare function convertPipfileLockToPyprojectToml(pipfileLock: PipfileLockLike): PyProjectToml;

package/dist/manifest/pipfile-parser.js

@@ -0,0 +1,262 @@
+"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 pipfile_parser_exports = {};
+__export(pipfile_parser_exports, {
+  convertPipfileLockToPyprojectToml: () => convertPipfileLockToPyprojectToml,
+  convertPipfileToPyprojectToml: () => convertPipfileToPyprojectToml
+});
+module.exports = __toCommonJS(pipfile_parser_exports);
+var import_pep508 = require("./pep508");
+var import_type = require("../util/type");
+const PYPI_INDEX_NAME = "pypi";
+function addDepSource(sources, dep) {
+  if (!dep.source) {
+    return;
+  }
+  if (Object.prototype.hasOwnProperty.call(sources, dep.name)) {
+    sources[dep.name].push(dep.source);
+  } else {
+    sources[dep.name] = [dep.source];
+  }
+}
+function isPypiSource(source) {
+  return typeof source?.name === "string" && source.name === PYPI_INDEX_NAME;
+}
+function processIndexSources(sources) {
+  const hasPypi = sources.some(isPypiSource);
+  const setExplicit = sources.length > 1 && hasPypi;
+  const indexes = [];
+  for (const source of sources) {
+    if (isPypiSource(source)) {
+      continue;
+    }
+    const entry = {
+      name: source.name,
+      url: source.url
+    };
+    if (setExplicit) {
+      entry.explicit = true;
+    }
+    indexes.push(entry);
+  }
+  return indexes;
+}
+function buildUvToolSection(sources, indexes) {
+  const uv = {};
+  if (indexes.length > 0) {
+    uv.index = indexes;
+  }
+  if (Object.keys(sources).length > 0) {
+    uv.sources = sources;
+  }
+  return Object.keys(uv).length > 0 ? uv : null;
+}
+function pipfileDepsToRequirements(entries) {
+  const deps = [];
+  for (const [name, properties] of Object.entries(entries)) {
+    const dep = pipfileDepToRequirement(name, properties);
+    deps.push(dep);
+  }
+  return deps;
+}
+function pipfileDepToRequirement(spec, properties) {
+  const [name, extrasFromName] = (0, import_pep508.splitExtras)(spec);
+  const dep = { name };
+  if (extrasFromName && extrasFromName.length > 0) {
+    dep.extras = extrasFromName;
+  }
+  if (typeof properties === "string") {
+    dep.version = properties;
+  } else if (properties && typeof properties === "object") {
+    if (properties.version) {
+      dep.version = properties.version;
+    }
+    if (properties.extras) {
+      dep.extras = (0, import_pep508.mergeExtras)(dep.extras, properties.extras);
+    }
+    if (properties.markers) {
+      dep.markers = properties.markers;
+    }
+    const source = buildDependencySource(properties);
+    if (source) {
+      dep.source = source;
+    }
+  }
+  return dep;
+}
+function pipfileLockDepsToRequirements(entries) {
+  const deps = [];
+  for (const [name, properties] of Object.entries(entries)) {
+    const dep = pipfileLockDepToRequirement(name, properties);
+    deps.push(dep);
+  }
+  return deps;
+}
+function pipfileLockDepToRequirement(spec, properties) {
+  const [name, extrasFromName] = (0, import_pep508.splitExtras)(spec);
+  const dep = { name };
+  if (extrasFromName && extrasFromName.length > 0) {
+    dep.extras = extrasFromName;
+  }
+  if (properties.version) {
+    dep.version = properties.version;
+  }
+  if (properties.extras) {
+    dep.extras = (0, import_pep508.mergeExtras)(dep.extras, properties.extras);
+  }
+  if (properties.markers) {
+    dep.markers = properties.markers;
+  }
+  const source = buildDependencySource(properties);
+  if (source) {
+    dep.source = source;
+  }
+  return dep;
+}
+function buildDependencySource(properties) {
+  const source = {};
+  if (properties.index && properties.index !== PYPI_INDEX_NAME) {
+    source.index = properties.index;
+  }
+  if (properties.git) {
+    source.git = properties.git;
+    if (properties.ref) {
+      source.rev = properties.ref;
+    }
+  }
+  if (properties.path) {
+    source.path = properties.path;
+    if (properties.editable) {
+      source.editable = true;
+    }
+  }
+  return Object.keys(source).length > 0 ? source : null;
+}
+function convertPipfileToPyprojectToml(pipfile) {
+  const sources = {};
+  const pyproject = {};
+  const deps = [];
+  for (const dep of pipfileDepsToRequirements(pipfile.packages || {})) {
+    deps.push((0, import_pep508.formatPep508)(dep));
+    addDepSource(sources, dep);
+  }
+  if (deps.length > 0) {
+    pyproject.project = {
+      dependencies: deps
+    };
+  }
+  const devDeps = [];
+  for (const dep of pipfileDepsToRequirements(pipfile["dev-packages"] || {})) {
+    devDeps.push((0, import_pep508.formatPep508)(dep));
+    addDepSource(sources, dep);
+  }
+  if (devDeps.length > 0) {
+    pyproject["dependency-groups"] = {
+      dev: devDeps
+    };
+  }
+  const RESERVED_KEYS = /* @__PURE__ */ new Set([
+    "packages",
+    "dev-packages",
+    "source",
+    "scripts",
+    "requires",
+    "pipenv"
+  ]);
+  for (const [sectionName, value] of Object.entries(pipfile)) {
+    if (RESERVED_KEYS.has(sectionName))
+      continue;
+    if (!(0, import_type.isPlainObject)(value))
+      continue;
+    const groupDeps = [];
+    for (const dep of pipfileDepsToRequirements(
+      value
+    )) {
+      groupDeps.push((0, import_pep508.formatPep508)(dep));
+      addDepSource(sources, dep);
+    }
+    if (groupDeps.length > 0) {
+      pyproject["dependency-groups"] = {
+        ...pyproject["dependency-groups"] || {},
+        [sectionName]: groupDeps
+      };
+    }
+  }
+  const indexes = processIndexSources(pipfile.source ?? []);
+  const uv = buildUvToolSection(sources, indexes);
+  if (uv) {
+    pyproject.tool = { uv };
+  }
+  return pyproject;
+}
+function convertPipfileLockToPyprojectToml(pipfileLock) {
+  const sources = {};
+  const pyproject = {};
+  const deps = [];
+  for (const dep of pipfileLockDepsToRequirements(pipfileLock.default || {})) {
+    deps.push((0, import_pep508.formatPep508)(dep));
+    addDepSource(sources, dep);
+  }
+  if (deps.length > 0) {
+    pyproject.project = {
+      dependencies: deps
+    };
+  }
+  const devDeps = [];
+  for (const dep of pipfileLockDepsToRequirements(pipfileLock.develop || {})) {
+    devDeps.push((0, import_pep508.formatPep508)(dep));
+    addDepSource(sources, dep);
+  }
+  if (devDeps.length > 0) {
+    pyproject["dependency-groups"] = {
+      dev: devDeps
+    };
+  }
+  const RESERVED_KEYS = /* @__PURE__ */ new Set(["_meta", "default", "develop"]);
+  for (const [sectionName, value] of Object.entries(pipfileLock)) {
+    if (RESERVED_KEYS.has(sectionName))
+      continue;
+    if (!(0, import_type.isPlainObject)(value))
+      continue;
+    const groupDeps = [];
+    for (const dep of pipfileLockDepsToRequirements(
+      value
+    )) {
+      groupDeps.push((0, import_pep508.formatPep508)(dep));
+      addDepSource(sources, dep);
+    }
+    if (groupDeps.length > 0) {
+      pyproject["dependency-groups"] = {
+        ...pyproject["dependency-groups"] || {},
+        [sectionName]: groupDeps
+      };
+    }
+  }
+  const indexes = processIndexSources(pipfileLock._meta?.sources ?? []);
+  const uv = buildUvToolSection(sources, indexes);
+  if (uv) {
+    pyproject.tool = { uv };
+  }
+  return pyproject;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertPipfileLockToPyprojectToml,
+  convertPipfileToPyprojectToml
+});

package/dist/manifest/pyproject/schema.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Zod schemas for pyproject.toml 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 pyproject/schema
+ */
+import type { z } from 'zod';
+import type { License, LicenseObject, Person, PyProjectBuildSystem, PyProjectDependencyGroups, PyProjectProject, PyProjectToml, PyProjectToolSection, Readme, ReadmeObject } from './types';
+/**
+ * Schema for [build-system] per PEP 518.
+ */
+export declare const PyProjectBuildSystemSchema: z.ZodType<PyProjectBuildSystem, z.ZodTypeDef, PyProjectBuildSystem>;
+/**
+ * Schema for author/maintainer entries.
+ */
+export declare const PersonSchema: z.ZodType<Person, z.ZodTypeDef, Person>;
+/**
+ * Schema for readme field as an object.
+ */
+export declare const ReadmeObjectSchema: z.ZodType<ReadmeObject, z.ZodTypeDef, ReadmeObject>;
+/**
+ * Schema for readme field (can be string or object).
+ */
+export declare const ReadmeSchema: z.ZodType<Readme, z.ZodTypeDef, Readme>;
+/**
+ * Schema for license field as an object.
+ */
+export declare const LicenseObjectSchema: z.ZodType<LicenseObject, z.ZodTypeDef, LicenseObject>;
+/**
+ * Schema for license field (can be string or object).
+ */
+export declare const LicenseSchema: z.ZodType<License, z.ZodTypeDef, License>;
+/**
+ * Schema for core PEP 621 fields for [project].
+ */
+export declare const PyProjectProjectSchema: z.ZodType<PyProjectProject, z.ZodTypeDef, PyProjectProject>;
+/**
+ * Schema for [dependency-groups].
+ */
+export declare const PyProjectDependencyGroupsSchema: z.ZodType<PyProjectDependencyGroups, z.ZodTypeDef, PyProjectDependencyGroups>;
+/**
+ * Schema for [tool.FOO] section.
+ */
+export declare const PyProjectToolSectionSchema: z.ZodType<PyProjectToolSection, z.ZodTypeDef, PyProjectToolSection>;
+/**
+ * Schema for a pyproject.toml file.
+ */
+export declare const PyProjectTomlSchema: z.ZodType<PyProjectToml, z.ZodTypeDef, PyProjectToml>;

package/dist/manifest/pyproject/schema.js

@@ -0,0 +1,56 @@
+"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, {
+  LicenseObjectSchema: () => LicenseObjectSchema,
+  LicenseSchema: () => LicenseSchema,
+  PersonSchema: () => PersonSchema,
+  PyProjectBuildSystemSchema: () => PyProjectBuildSystemSchema,
+  PyProjectDependencyGroupsSchema: () => PyProjectDependencyGroupsSchema,
+  PyProjectProjectSchema: () => PyProjectProjectSchema,
+  PyProjectTomlSchema: () => PyProjectTomlSchema,
+  PyProjectToolSectionSchema: () => PyProjectToolSectionSchema,
+  ReadmeObjectSchema: () => ReadmeObjectSchema,
+  ReadmeSchema: () => ReadmeSchema
+});
+module.exports = __toCommonJS(schema_exports);
+var import_schema = require("./schema.zod");
+const PyProjectBuildSystemSchema = import_schema.pyProjectBuildSystemSchema.passthrough();
+const PersonSchema = import_schema.personSchema.passthrough();
+const ReadmeObjectSchema = import_schema.readmeObjectSchema.passthrough();
+const ReadmeSchema = import_schema.readmeSchema;
+const LicenseObjectSchema = import_schema.licenseObjectSchema.passthrough();
+const LicenseSchema = import_schema.licenseSchema;
+const PyProjectProjectSchema = import_schema.pyProjectProjectSchema.passthrough();
+const PyProjectDependencyGroupsSchema = import_schema.pyProjectDependencyGroupsSchema;
+const PyProjectToolSectionSchema = import_schema.pyProjectToolSectionSchema.passthrough();
+const PyProjectTomlSchema = import_schema.pyProjectTomlSchema.passthrough();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LicenseObjectSchema,
+  LicenseSchema,
+  PersonSchema,
+  PyProjectBuildSystemSchema,
+  PyProjectDependencyGroupsSchema,
+  PyProjectProjectSchema,
+  PyProjectTomlSchema,
+  PyProjectToolSectionSchema,
+  ReadmeObjectSchema,
+  ReadmeSchema
+});