@prisma/cli 3.0.0-dev.97.1 → 8.0.0-rc.1

package/dist/controllers/select-prompt-port.js

@@ -4,6 +4,7 @@ function createSelectPromptPort(context) {
 	return { select: ({ message, choices }) => selectPrompt({
 		input: context.runtime.stdin,
 		output: context.runtime.stderr,
+		signal: context.runtime.signal,
 		message,
 		choices
 	}) };

package/dist/{shell/errors.js → errors.js}

@@ -1,4 +1,4 @@
-//#region src/shell/errors.ts
+//#region src/errors.ts
 var CliError = class extends Error {
 	code;
 	domain;
@@ -44,6 +44,12 @@ function usageError(summary, why, fix, nextSteps = [], domain = "cli") {
 		nextSteps
 	});
 }
+function isUsageError(error, summary) {
+	return isErrorRecord(error) && error.code === "USAGE_ERROR" && (summary === void 0 || error.summary === summary);
+}
+function isErrorRecord(error) {
+	return typeof error === "object" && error !== null;
+}
 function authRequiredError(nextSteps = ["prisma-cli auth login"], options = {}) {
 	return new CliError({
 		code: "AUTH_REQUIRED",
@@ -81,44 +87,6 @@ function commandCanceledError() {
 function workspaceRequiredError() {
 	return usageError("Workspace required", "This command needs an active workspace, but the authenticated session does not have one.", "Run prisma-cli auth login and choose a workspace.", ["prisma-cli auth login"], "auth");
 }
-function workspaceSwitchUnavailableError() {
-	return new CliError({
-		code: "WORKSPACE_SWITCH_UNAVAILABLE",
-		domain: "auth",
-		summary: "Workspace switching is unavailable",
-		why: "PRISMA_SERVICE_TOKEN is set, so authenticated commands use that token instead of local OAuth workspaces.",
-		fix: "Unset PRISMA_SERVICE_TOKEN to switch between local OAuth workspaces, or use a token for the workspace you want.",
-		exitCode: 1,
-		nextSteps: ["unset PRISMA_SERVICE_TOKEN", "prisma-cli auth workspace list"]
-	});
-}
-function workspaceNotAuthenticatedError(workspaceRef) {
-	return new CliError({
-		code: "WORKSPACE_NOT_AUTHENTICATED",
-		domain: "auth",
-		summary: "Workspace is not authenticated",
-		why: `No stored OAuth session matched "${workspaceRef}".`,
-		fix: "Run prisma-cli auth login and authorize that workspace, then switch to it.",
-		meta: { workspaceRef },
-		exitCode: 1,
-		nextSteps: ["prisma-cli auth workspace list", "prisma-cli auth login"]
-	});
-}
-function workspaceAmbiguousError(workspaceRef, matches) {
-	return new CliError({
-		code: "WORKSPACE_AMBIGUOUS",
-		domain: "auth",
-		summary: "Workspace name is ambiguous",
-		why: `Multiple authenticated workspaces matched "${workspaceRef}".`,
-		fix: "Run prisma-cli auth workspace list and switch by workspace id.",
-		meta: {
-			workspaceRef,
-			matches
-		},
-		exitCode: 2,
-		nextSteps: ["prisma-cli auth workspace list"]
-	});
-}
 function featureUnavailableError(summary, why, fix, nextSteps = [], domain = "cli") {
 	return new CliError({
 		code: "FEATURE_UNAVAILABLE",
@@ -131,4 +99,4 @@ function featureUnavailableError(summary, why, fix, nextSteps = [], domain = "cl
 	});
 }
 //#endregion
-export { CliError, authConfigInvalidError, authRequiredError, commandCanceledError, featureUnavailableError, usageError, workspaceAmbiguousError, workspaceNotAuthenticatedError, workspaceRequiredError, workspaceSwitchUnavailableError };
+export { CliError, authConfigInvalidError, authRequiredError, commandCanceledError, featureUnavailableError, isUsageError, usageError, workspaceRequiredError };

package/dist/lib/agent/cli-command.js

@@ -0,0 +1,20 @@
+import { formatPrismaCliCommand } from "../../cli-command.js";
+import { resolvePackageRunner, resolvePackageRunnerSync } from "./package-manager.js";
+//#region src/lib/agent/cli-command.ts
+async function resolvePrismaCliPackageCommandFormatter(options) {
+	return createPrismaCliPackageCommandFormatter(await resolvePackageRunner(options));
+}
+async function resolvePrismaCliPackageCommand(options) {
+	return (await resolvePrismaCliPackageCommandFormatter(options))(options.args);
+}
+function resolvePrismaCliPackageCommandFormatterSync(cwd) {
+	return createPrismaCliPackageCommandFormatter(resolvePackageRunnerSync(cwd));
+}
+function resolvePrismaCliPackageCommandSync(cwd, args) {
+	return resolvePrismaCliPackageCommandFormatterSync(cwd)(args);
+}
+function createPrismaCliPackageCommandFormatter(packageRunner) {
+	return (args) => formatPrismaCliCommand(args, { packageRunner });
+}
+//#endregion
+export { resolvePrismaCliPackageCommand, resolvePrismaCliPackageCommandFormatterSync, resolvePrismaCliPackageCommandSync };

package/dist/lib/agent/constants.js

@@ -0,0 +1,12 @@
+//#region src/lib/agent/constants.ts
+const PRISMA_SKILLS_SOURCE = "prisma/skills";
+const PRISMA_SKILLS_LOCK_FILENAME = "skills-lock.json";
+const SKILLS_CLI_PACKAGE = "skills@latest";
+const DEFAULT_PRISMA_AGENT_SKILLS = ["*"];
+const PRISMA_COMPUTE_AGENT_SKILL = "prisma-compute";
+const DEFAULT_PRISMA_AGENT_TARGETS = ["codex", "claude-code"];
+const PRISMA_AGENT_INSTALL_ARGS = ["agent", "install"];
+const PRISMA_AGENT_UPDATE_ARGS = ["agent", "update"];
+const PRISMA_AGENT_STATUS_ARGS = ["agent", "status"];
+//#endregion
+export { DEFAULT_PRISMA_AGENT_SKILLS, DEFAULT_PRISMA_AGENT_TARGETS, PRISMA_AGENT_INSTALL_ARGS, PRISMA_AGENT_STATUS_ARGS, PRISMA_AGENT_UPDATE_ARGS, PRISMA_COMPUTE_AGENT_SKILL, PRISMA_SKILLS_LOCK_FILENAME, PRISMA_SKILLS_SOURCE, SKILLS_CLI_PACKAGE };

package/dist/lib/agent/package-manager.js

@@ -0,0 +1,99 @@
+import { readFileSync, statSync } from "node:fs";
+import path from "node:path";
+//#region src/lib/agent/package-manager.ts
+const LOCKFILE_PACKAGE_MANAGERS = [
+	{
+		packageManager: "bun",
+		fileNames: ["bun.lock", "bun.lockb"]
+	},
+	{
+		packageManager: "pnpm",
+		fileNames: ["pnpm-lock.yaml", "pnpm-workspace.yaml"]
+	},
+	{
+		packageManager: "yarn",
+		fileNames: ["yarn.lock"]
+	},
+	{
+		packageManager: "npm",
+		fileNames: ["package-lock.json", "npm-shrinkwrap.json"]
+	}
+];
+async function resolveSkillsPackageRunner(options) {
+	return resolvePackageRunner(options);
+}
+async function resolvePackageRunner(options) {
+	options.signal.throwIfAborted();
+	const packageManager = detectPackageManagerSync(options.cwd, options.signal) ?? "npm";
+	options.signal.throwIfAborted();
+	return packageRunnerForPackageManager(packageManager);
+}
+function resolvePackageRunnerSync(cwd) {
+	return packageRunnerForPackageManager(detectPackageManagerSync(cwd) ?? "npm");
+}
+function detectPackageManagerSync(cwd, signal) {
+	let directory = path.resolve(cwd);
+	while (true) {
+		signal?.throwIfAborted();
+		const packageJsonManager = readPackageJsonPackageManager(directory);
+		if (packageJsonManager) return packageJsonManager;
+		const lockfileManager = readLockfilePackageManager(directory, signal);
+		if (lockfileManager) return lockfileManager;
+		const parent = path.dirname(directory);
+		if (parent === directory) return null;
+		directory = parent;
+	}
+}
+function readPackageJsonPackageManager(directory) {
+	const packageJsonPath = path.join(directory, "package.json");
+	let content;
+	try {
+		content = readFileSync(packageJsonPath, "utf8");
+	} catch (error) {
+		if (isMissingFileError(error)) return null;
+		throw error;
+	}
+	try {
+		return parsePackageManager(JSON.parse(content).packageManager);
+	} catch {
+		return null;
+	}
+}
+function readLockfilePackageManager(directory, signal) {
+	for (const candidate of LOCKFILE_PACKAGE_MANAGERS) for (const fileName of candidate.fileNames) {
+		signal?.throwIfAborted();
+		if (fileExists(path.join(directory, fileName))) return candidate.packageManager;
+	}
+	return null;
+}
+function fileExists(filePath) {
+	try {
+		return statSync(filePath).isFile();
+	} catch (error) {
+		if (isMissingFileError(error)) return false;
+		throw error;
+	}
+}
+function parsePackageManager(value) {
+	if (typeof value !== "string") return null;
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "bun" || normalized.startsWith("bun@")) return "bun";
+	if (normalized === "pnpm" || normalized.startsWith("pnpm@")) return "pnpm";
+	if (normalized === "yarn" || normalized.startsWith("yarn@")) return "yarn";
+	if (normalized === "npm" || normalized.startsWith("npm@")) return "npm";
+	return null;
+}
+function packageRunnerForPackageManager(packageManager) {
+	switch (packageManager) {
+		case "bun": return ["bunx"];
+		case "pnpm": return ["pnpm", "dlx"];
+		case "yarn": return ["yarn", "dlx"];
+		case "npm": return ["npx", "-y"];
+	}
+}
+function isMissingFileError(error) {
+	const code = error.code;
+	return code === "ENOENT" || code === "ENOTDIR";
+}
+//#endregion
+export { detectPackageManagerSync, resolvePackageRunner, resolvePackageRunnerSync, resolveSkillsPackageRunner };

package/dist/lib/agent/setup-status.js

@@ -0,0 +1,83 @@
+import { PRISMA_SKILLS_LOCK_FILENAME } from "./constants.js";
+import path from "node:path";
+import { readFile, stat } from "node:fs/promises";
+import { findComputeConfigDir } from "@prisma/compute-sdk/config";
+//#region src/lib/agent/setup-status.ts
+async function readPrismaAgentSetupStatus(options) {
+	const setupCwd = await resolvePrismaAgentSetupCwd(options);
+	const skillsLockPath = path.join(setupCwd, PRISMA_SKILLS_LOCK_FILENAME);
+	const [skillsInstalled, promptDismissedAt] = await Promise.all([hasPrismaSkillsLock(skillsLockPath, options.signal, options.requiredSkill), options.stateStore?.readAgentSetupPromptDismissedAt() ?? null]);
+	return {
+		skillsLockPath: path.basename(skillsLockPath),
+		skillsInstalled,
+		promptDismissedAt
+	};
+}
+async function resolvePrismaAgentSetupCwd(options) {
+	options.signal.throwIfAborted();
+	const configDir = await findComputeConfigDir(options.cwd, options.signal);
+	options.signal.throwIfAborted();
+	return configDir ?? options.cwd;
+}
+function isPrismaAgentSetupComplete(status) {
+	return status.skillsInstalled;
+}
+function shouldOfferPrismaAgentSetup(status) {
+	return !isPrismaAgentSetupComplete(status) && !status.promptDismissedAt;
+}
+async function isLikelyProjectDirectory(options) {
+	return (await Promise.all([
+		"package.json",
+		"prisma.compute.ts",
+		"prisma.config.ts",
+		".git"
+	].map((fileName) => pathExists(path.join(options.cwd, fileName), options.signal)))).some(Boolean);
+}
+async function hasPrismaSkillsLock(filePath, signal, requiredSkill) {
+	try {
+		const raw = await readFile(filePath, {
+			encoding: "utf8",
+			signal
+		});
+		return hasPrismaSkillsLockEntry(JSON.parse(raw), requiredSkill);
+	} catch (error) {
+		if (isNotFoundError(error) || error instanceof SyntaxError) return false;
+		throw error;
+	}
+}
+function hasPrismaSkillsLockEntry(value, requiredSkill) {
+	if (!isRecord(value)) return false;
+	if (requiredSkill) return skillLockEntryUsesPrismaSource(readSkillLockEntries(value)[requiredSkill]);
+	if (readLegacySources(value).includes("prisma/skills")) return true;
+	return Object.values(readSkillLockEntries(value)).some(skillLockEntryUsesPrismaSource);
+}
+function readLegacySources(value) {
+	return Array.isArray(value.sources) ? value.sources.filter((source) => typeof source === "string") : [];
+}
+function readSkillLockEntries(value) {
+	return isRecord(value.skills) ? value.skills : {};
+}
+function skillLockEntryUsesPrismaSource(value) {
+	return isRecord(value) && value.source === "prisma/skills";
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+async function pathExists(filePath, signal) {
+	signal.throwIfAborted();
+	try {
+		await stat(filePath);
+		signal.throwIfAborted();
+		return true;
+	} catch (error) {
+		if (signal.aborted) throw error;
+		if (isNotFoundError(error)) return false;
+		throw error;
+	}
+}
+function isNotFoundError(error) {
+	const code = error.code;
+	return code === "ENOENT" || code === "ENOTDIR";
+}
+//#endregion
+export { isLikelyProjectDirectory, readPrismaAgentSetupStatus, resolvePrismaAgentSetupCwd, shouldOfferPrismaAgentSetup };