@prisma/cli 3.0.0-beta.0 → 3.0.0-beta.2

package/dist/lib/project/resolution.js

@@ -1,73 +1,33 @@
 import { CliError } from "../../shell/errors.js";
-import { canPrompt } from "../../shell/runtime.js";
+import { formatCommandArgument } from "../../shell/command-arguments.js";
+import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, readLocalResolutionPin } from "./local-pin.js";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 //#region src/lib/project/resolution.ts
 async function resolveProjectTarget(options) {
 	const projects = await options.listProjects();
-	const inferredName = await inferTargetName(options.context.runtime.cwd);
-	if (options.explicitProject) return rememberIfRequested(options, resolveExplicitProject(options.explicitProject, projects, options.workspace), "explicit", {
-		targetName: options.explicitProject,
-		targetNameSource: "explicit"
+	const target = await resolveBoundProjectTarget(options, projects, { allowEnvProjectId: true });
+	if (target) return target;
+	throw await projectSetupRequiredError({
+		cwd: options.context.runtime.cwd,
+		projects,
+		commandName: options.commandName
 	});
-	const platformMapping = await resolveDurablePlatformMapping();
-	if (platformMapping) return rememberIfRequested(options, platformMapping, "platform-mapping");
-	let staleRemembered = false;
-	if (!options.allowCreate) {
-		const rememberedResult = await resolveRememberedProject(options, projects);
-		if (rememberedResult.target) return rememberedResult.target;
-		staleRemembered = rememberedResult.stale;
-	}
-	const packageName = inferredName.source === "package-name" ? inferredName.name : null;
-	if (packageName) {
-		const matches = projects.filter((project) => projectMatchesPackageName(project, packageName));
-		if (matches.length === 1) return rememberIfRequested(options, matches[0], "package-name", {
-			targetName: packageName,
-			targetNameSource: "package-name"
-		});
-		if (matches.length > 1) return resolveAmbiguousProject(options, matches, packageName, "package-name");
-	}
-	if (options.allowCreate && options.createProject) {
-		if (inferredName.name) {
-			const existing = projects.filter((project) => projectMatchesPackageName(project, inferredName.name));
-			if (existing.length === 1) return rememberIfRequested(options, existing[0], inferredName.source, {
-				targetName: inferredName.name,
-				targetNameSource: inferredName.source
-			});
-			if (existing.length > 1) return resolveAmbiguousProject(options, existing, inferredName.name, inferredName.source);
-			return rememberIfRequested(options, await options.createProject(inferredName.name), "created", {
-				targetName: inferredName.name,
-				targetNameSource: inferredName.source
-			});
-		}
-	}
-	if (options.prompt && canPrompt(options.context) && projects.length > 0) return rememberIfRequested(options, await options.prompt.select({
-		message: "Select a project",
-		choices: sortProjects(projects).map((project) => ({
-			label: `${project.name} (${project.id})`,
-			value: project
-		}))
-	}), "prompt");
-	if (staleRemembered && projects.length > 1) throw localStateStaleError();
-	throw projectUnresolvedError();
-}
-async function resolveRememberedProject(options, projects) {
-	const remembered = await options.context.stateStore.readRememberedProject(options.workspace.id);
-	if (!remembered) return {
-		target: null,
-		stale: false
-	};
-	const matched = projects.find((project) => project.id === remembered.id);
-	if (!matched) return {
-		target: null,
-		stale: true
-	};
+}
+async function inspectProjectBinding(options) {
+	const projects = await options.listProjects();
+	const target = await resolveBoundProjectTarget(options, projects, { allowEnvProjectId: false });
+	if (target) return target;
 	return {
-		target: await rememberIfRequested(options, matched, "remembered-local", {
-			targetName: remembered.name,
-			targetNameSource: "remembered-local"
-		}),
-		stale: false
+		workspace: options.workspace,
+		project: null,
+		localBinding: { status: "not-linked" },
+		resolution: { projectSource: "unbound" },
+		...await buildProjectSetupSuggestion({
+			cwd: options.context.runtime.cwd,
+			projects,
+			commandName: options.commandName ?? "project show"
+		})
 	};
 }
 function projectNotFoundError(projectRef, workspace) {
@@ -99,27 +59,77 @@ function projectAmbiguousError(projectRef, matches) {
 		nextSteps
 	});
 }
-function projectUnresolvedError() {
+function localStateStaleError() {
 	return new CliError({
-		code: "PROJECT_UNRESOLVED",
+		code: "LOCAL_STATE_STALE",
 		domain: "project",
-		summary: "No project is resolved for this directory",
-		why: "No project could be resolved from explicit input, platform mappings, remembered local context, or package metadata.",
-		fix: "Pass --project <id-or-name> on the command that needs a project, or add a package.json name that matches an accessible project.",
+		summary: "Local project binding is stale",
+		why: `The target recorded in ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} is no longer available in the selected workspace.`,
+		fix: `Delete ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH}, then choose a Project explicitly.`,
+		meta: { pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH },
 		exitCode: 1,
-		nextSteps: ["prisma-cli project list", "prisma-cli project show --project <id-or-name>"]
+		nextSteps: ["prisma-cli project list", "prisma-cli project link <id-or-name>"]
 	});
 }
-function localStateStaleError() {
+async function buildProjectSetupSuggestion(options) {
+	const suggestedName = await inferTargetName(options.cwd);
+	const candidates = sortProjects(options.projects.filter((project) => projectMatchesSuggestedName(project, suggestedName.name))).map(toProjectSummary);
+	return {
+		suggestedProjectName: suggestedName.name,
+		suggestedProjectNameSource: suggestedName.source,
+		candidates,
+		recoveryCommands: buildProjectRecoveryCommands(options.commandName)
+	};
+}
+async function projectSetupRequiredError(options) {
+	const suggestion = await buildProjectSetupSuggestion(options);
 	return new CliError({
-		code: "LOCAL_STATE_STALE",
+		code: "PROJECT_SETUP_REQUIRED",
 		domain: "project",
-		summary: "Remembered project context is stale",
-		why: "The remembered project is no longer available in the selected workspace, and automatic resolution would be ambiguous.",
-		fix: "Pass --project <id-or-name> to choose the project explicitly.",
+		summary: "Choose a Project before running this command",
+		why: `This directory is not linked to a Prisma Project, and ${options.commandName ? `prisma-cli ${options.commandName}` : "this command"} will not choose one from package or directory names.`,
+		fix: "Link the directory to an existing Project, or pass --project <id-or-name> for this command.",
+		meta: { ...suggestion },
 		exitCode: 1,
-		nextSteps: ["prisma-cli project list"]
+		nextSteps: ["prisma-cli project list", ...suggestion.recoveryCommands],
+		nextActions: buildProjectSetupNextActions({
+			commandName: options.commandName,
+			suggestedProjectName: suggestion.suggestedProjectName
+		})
+	});
+}
+function buildProjectSetupNextActions(options = {}) {
+	const recoveryCommands = buildProjectRecoveryCommands(options.commandName);
+	const linkCommand = recoveryCommands[0] ?? "prisma-cli project link <id-or-name>";
+	const retryCommand = recoveryCommands[1];
+	const actions = [{
+		kind: "user-choice",
+		journey: "project-setup",
+		label: "Ask the user whether to link an existing Project or create a new one",
+		commands: ["prisma-cli project list", ...recoveryCommands],
+		reason: options.reason ?? "This directory is not linked to a Prisma Project. Package and directory names are suggestions only, not a safe Project selection."
+	}, {
+		kind: "run-command",
+		journey: "project-setup",
+		label: "Link the chosen Project",
+		command: linkCommand,
+		reason: "Linking writes the durable local Project binding for this directory."
+	}];
+	const createCommand = options.createCommand ?? (options.suggestedProjectName ? `prisma-cli project create ${formatCommandArgument(options.suggestedProjectName)}` : void 0);
+	if (createCommand) actions.push({
+		kind: "run-command",
+		journey: "project-setup",
+		label: "Create and link a new Project",
+		command: createCommand,
+		reason: "Use this when the user wants a new Prisma Project instead of an existing one."
+	});
+	if (options.commandName) actions.push({
+		kind: "run-command",
+		journey: "recover",
+		label: "Retry with an explicit Project",
+		command: retryCommand ?? `prisma-cli ${options.commandName} --project <id-or-name>`
 	});
+	return actions;
 }
 async function readPackageName(cwd) {
 	try {
@@ -157,33 +167,46 @@ function resolveExplicitProject(projectRef, projects, workspace) {
 	if (matches.length > 1) throw projectAmbiguousError(projectRef, matches);
 	throw projectNotFoundError(projectRef, workspace);
 }
-function resolveAmbiguousProject(options, matches, projectRef, targetNameSource) {
-	if (options.prompt && canPrompt(options.context)) return options.prompt.select({
-		message: "Select a project",
-		choices: sortProjects(matches).map((project) => ({
-			label: `${project.name} (${project.id})`,
-			value: project
-		}))
-	}).then((selected) => rememberIfRequested(options, selected, "prompt", {
-		targetName: projectRef,
-		targetNameSource
-	}));
-	throw projectAmbiguousError(projectRef, matches);
-}
-function projectMatchesPackageName(project, packageName) {
-	return project.id === packageName || project.name === packageName || project.slug === packageName;
+function projectMatchesSuggestedName(project, suggestedName) {
+	return project.id === suggestedName || project.name === suggestedName || project.slug === suggestedName;
 }
 async function resolveDurablePlatformMapping() {
 	return null;
 }
-async function rememberIfRequested(options, project, projectSource, resolutionDetails) {
-	if (options.remember) await options.context.stateStore.setRememberedProject({
-		id: project.id,
-		name: project.name,
-		workspaceId: options.workspace.id
+async function resolveBoundProjectTarget(options, projects, settings) {
+	if (options.explicitProject) return resolvedTarget(options.workspace, resolveExplicitProject(options.explicitProject, projects, options.workspace), "explicit", {
+		targetName: options.explicitProject,
+		targetNameSource: "explicit"
+	});
+	if (settings.allowEnvProjectId && options.envProjectId) {
+		const project = projects.find((candidate) => candidate.id === options.envProjectId);
+		if (!project) throw projectNotFoundError(options.envProjectId, options.workspace);
+		return resolvedTarget(options.workspace, project, "env", {
+			targetName: options.envProjectId,
+			targetNameSource: "env"
+		});
+	}
+	const localPin = await readLocalResolutionPin(options.context.runtime.cwd);
+	if (localPin.kind === "invalid") throw localStateStaleError();
+	if (localPin.kind === "present") {
+		if (localPin.pin.workspaceId !== options.workspace.id) throw localStateStaleError();
+		const project = projects.find((candidate) => candidate.id === localPin.pin.projectId);
+		if (!project) throw localStateStaleError();
+		return resolvedTarget(options.workspace, project, "local-pin", {
+			targetName: project.name,
+			targetNameSource: "local-pin"
+		});
+	}
+	const platformMapping = await resolveDurablePlatformMapping();
+	if (platformMapping && platformMapping.workspace.id === options.workspace.id) return resolvedTarget(options.workspace, platformMapping, "platform-mapping", {
+		targetName: platformMapping.name,
+		targetNameSource: "platform-mapping"
 	});
+	return null;
+}
+function resolvedTarget(workspace, project, projectSource, resolutionDetails) {
 	return {
-		workspace: options.workspace,
+		workspace,
 		project: toProjectSummary(project),
 		resolution: {
 			projectSource,
@@ -191,11 +214,17 @@ async function rememberIfRequested(options, project, projectSource, resolutionDe
 		}
 	};
 }
+function buildProjectRecoveryCommands(commandName) {
+	const commands = ["prisma-cli project link <id-or-name>"];
+	if (commandName) commands.push(`prisma-cli ${commandName} --project <id-or-name>`);
+	return commands;
+}
 function toProjectSummary(project) {
 	return {
 		id: project.id,
-		name: project.name
+		name: project.name,
+		...project.url ? { url: project.url } : {}
 	};
 }
 //#endregion
-export { inferTargetName, projectNotFoundError, resolveProjectTarget, sortProjects };
+export { buildProjectSetupNextActions, inferTargetName, inspectProjectBinding, projectAmbiguousError, projectNotFoundError, resolveDurablePlatformMapping, resolveProjectTarget, sortProjects };

package/dist/lib/project/setup.js

@@ -0,0 +1,89 @@
+import { CliError, usageError } from "../../shell/errors.js";
+import "../../shell/command-arguments.js";
+import { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, ensureLocalResolutionPinGitignore, writeLocalResolutionPin } from "./local-pin.js";
+import { projectAmbiguousError, projectNotFoundError } from "./resolution.js";
+//#region src/lib/project/setup.ts
+function isValidProjectSetupName(projectName) {
+	return projectName.trim().length > 0;
+}
+function validateProjectSetupNameText(value, fallback) {
+	if ((value?.trim() || fallback).trim().length > 0) return;
+	return "Enter a Project name.";
+}
+function resolveProjectForSetup(projectRef, projects, workspace) {
+	const matches = projects.filter((project) => project.id === projectRef || project.name === projectRef);
+	if (matches.length === 1) return matches[0];
+	if (matches.length > 1) throw projectAmbiguousError(projectRef, matches);
+	throw projectNotFoundError(projectRef, workspace);
+}
+async function bindProjectToDirectory(context, workspace, project, action) {
+	await writeLocalResolutionPin(context.runtime.cwd, {
+		workspaceId: workspace.id,
+		projectId: project.id
+	});
+	await ensureLocalResolutionPinGitignore(context.runtime.cwd);
+	return {
+		workspace,
+		project,
+		directory: formatSetupDirectory(context.runtime.cwd),
+		localPin: {
+			path: LOCAL_RESOLUTION_PIN_RELATIVE_PATH,
+			written: true
+		},
+		action
+	};
+}
+function toProjectSummary(project) {
+	return {
+		id: project.id,
+		name: project.name,
+		...project.url ? { url: project.url } : {}
+	};
+}
+function projectSetupNameRequiredError(command) {
+	return usageError("Project create requires a name", "The project name must be a non-empty value.", "Pass a Project name explicitly.", [`prisma-cli ${command} my-app`], "project");
+}
+function projectCreateFailedError(error, projectName, workspace, options) {
+	const status = extractHttpStatus(error);
+	if (status === 401 || status === 403) return new CliError({
+		code: "PROJECT_CREATE_FAILED",
+		domain: "project",
+		summary: `Could not create Project "${projectName}"`,
+		why: `The platform rejected the Project create in workspace "${workspace.name}" (HTTP ${status}).`,
+		fix: options.permissionFix,
+		debug: formatDebugDetails(error),
+		exitCode: 1,
+		nextSteps: options.nextSteps
+	});
+	return new CliError({
+		code: "PROJECT_CREATE_FAILED",
+		domain: "project",
+		summary: `Could not create Project "${projectName}"`,
+		why: error instanceof Error ? error.message : String(error),
+		fix: options.fallbackFix,
+		debug: formatDebugDetails(error),
+		exitCode: 1,
+		nextSteps: options.nextSteps
+	});
+}
+function formatSetupDirectory(cwd) {
+	const basename = cwd.split(/[\\/]/).filter(Boolean).pop();
+	return basename ? `./${basename}` : ".";
+}
+function extractHttpStatus(error) {
+	if (!error || typeof error !== "object") return null;
+	const candidate = error;
+	if (typeof candidate.statusCode === "number") return candidate.statusCode;
+	if (typeof candidate.status === "number") return candidate.status;
+	if (typeof candidate.message === "string") {
+		const match = /\(HTTP (\d{3})\)/.exec(candidate.message);
+		if (match) return Number.parseInt(match[1], 10);
+	}
+	return null;
+}
+function formatDebugDetails(error) {
+	if (error instanceof Error) return error.stack ?? error.message;
+	return typeof error === "string" ? error : null;
+}
+//#endregion
+export { bindProjectToDirectory, isValidProjectSetupName, projectCreateFailedError, projectSetupNameRequiredError, resolveProjectForSetup, toProjectSummary, validateProjectSetupNameText };

package/dist/presenters/auth.js

@@ -7,9 +7,10 @@ function renderAuthSuccess(context, descriptor, command, result) {
 			key: "provider",
 			value: providerLabel(result.provider)
 		});
-		if (result.user) rows.push({
+		const userLabel = authUserLabel(result);
+		if (userLabel) rows.push({
 			key: "user",
-			value: result.user.email
+			value: userLabel
 		});
 		if (result.workspace?.name) rows.push({
 			key: "workspace",
@@ -45,10 +46,7 @@ function renderAuthSuccess(context, descriptor, command, result) {
 				value: "signed in",
 				tone: "success"
 			},
-			...result.user ? [{
-				key: "user",
-				value: result.user.email
-			}] : [],
+			...authUserRows(result),
 			...result.provider ? [{
 				key: "provider",
 				value: providerLabel(result.provider)
@@ -69,5 +67,20 @@ function providerLabel(provider) {
 	if (provider === "google") return "Google";
 	return "";
 }
+function authUserLabel(result) {
+	return result.user?.email ?? credentialUserLabel(result);
+}
+function authUserRows(result) {
+	const userLabel = authUserLabel(result);
+	return userLabel ? [{
+		key: "user",
+		value: userLabel
+	}] : [];
+}
+function credentialUserLabel(result) {
+	if (result.credential?.type === "service_token") return result.credential.name ? `<service token: ${result.credential.name}>` : "<service token>";
+	if (result.credential?.type === "management_token") return result.credential.name ? `<management token: ${result.credential.name}>` : "<management token>";
+	return null;
+}
 //#endregion
 export { renderAuthSuccess };

package/dist/presenters/project.js

@@ -1,7 +1,11 @@
+import { padDisplay, renderNextSteps, renderSummaryLine } from "../shell/ui.js";
+import { formatDescriptorLabel } from "../shell/command-meta.js";
+import { formatCommandArgument } from "../shell/command-arguments.js";
 import { renderList, renderMutate, renderShow, serializeList } from "../output/patterns.js";
+import path from "node:path";
 //#region src/presenters/project.ts
 function renderProjectList(context, descriptor, result) {
-	return renderList({
+	const lines = renderList({
 		title: "Listing projects for the authenticated workspace.",
 		descriptor,
 		parentContext: {
@@ -16,41 +20,53 @@ function renderProjectList(context, descriptor, result) {
 		})),
 		emptyMessage: "No projects found."
 	}, context.ui);
+	if (result.localBinding?.status === "not-linked" || result.localBinding?.status === "invalid") lines.push(...renderNextSteps(["Link an existing Project you choose: prisma-cli project link <id-or-name>", "Create a new Project: prisma-cli project create <name>"]));
+	return lines;
 }
 function serializeProjectList(result) {
-	return serializeList({
-		context: { workspace: result.workspace.name },
-		items: result.projects.map((project) => ({
-			noun: "project",
-			label: project.name,
-			id: project.id,
-			status: null
-		}))
-	});
+	return {
+		...serializeList({
+			context: { workspace: result.workspace.name },
+			items: result.projects.map((project) => ({
+				noun: "project",
+				label: project.name,
+				id: project.id,
+				status: null
+			}))
+		}),
+		localBinding: result.localBinding ?? null
+	};
 }
 function renderProjectShow(context, descriptor, result) {
-	return renderShow({
-		title: "Showing the project Prisma resolves for this directory.",
-		descriptor,
-		fields: [
-			{
+	if (result.project === null) {
+		const lines = renderShow({
+			title: "This directory is not linked to a Prisma Project.",
+			descriptor,
+			fields: [{
 				key: "workspace",
 				value: result.workspace.name
-			},
-			{
+			}, {
 				key: "project",
-				value: result.project.name
-			},
-			{
-				key: "resolution",
-				value: formatProjectSource(result.resolution.projectSource)
-			}
-		]
-	}, context.ui);
+				value: "Not linked",
+				tone: "warning"
+			}]
+		}, context.ui);
+		lines.push(...renderNextSteps(["Link an existing Project you choose: prisma-cli project link <id-or-name>", `Create a new Project: prisma-cli project create ${formatCommandArgument(result.suggestedProjectName)}`]));
+		return lines;
+	}
+	return renderBoundProjectShow(context, descriptor, result);
 }
 function serializeProjectShow(result) {
 	return result;
 }
+function renderProjectSetup(context, _descriptor, result) {
+	const lines = result.action === "created" ? [renderSummaryLine(context.ui, "success", `Created Project "${result.project.name}"`)] : [];
+	lines.push(renderSummaryLine(context.ui, "success", `Linked "${result.directory}" to Project "${result.project.name}"`), `Saved ${result.localPin.path}`);
+	return lines;
+}
+function serializeProjectSetup(result) {
+	return result;
+}
 function renderGitConnect(context, descriptor, result) {
 	const connection = result.repositoryConnection;
 	return renderMutate({
@@ -102,18 +118,31 @@ function renderGitDisconnect(context, descriptor, result) {
 		details: ["GitHub branch automation is no longer active for this project."]
 	}, context.ui);
 }
-function formatProjectSource(source) {
-	switch (source) {
-		case "explicit": return "explicit";
-		case "env": return "environment";
-		case "local-pin": return "local pin";
-		case "platform-mapping": return "platform mapping";
-		case "remembered-local": return "remembered local context";
-		case "package-name": return "package name";
-		case "directory-name": return "directory name";
-		case "created": return "created";
-		case "prompt": return "prompt";
+function renderBoundProjectShow(context, descriptor, result) {
+	const { ui } = context;
+	const rail = ui.dim("│");
+	const keyWidth = 10;
+	const platform = `${result.workspace.name} / ${result.project.name}`;
+	const lines = [
+		`${ui.strong(formatDescriptorLabel(descriptor))} ${ui.dim("→")} ${ui.dim("This directory is linked to the following platform project.")}`,
+		"",
+		`${rail}  ${ui.accent(padDisplay("local repo", keyWidth))}  ${formatLocalRepoPath(context.runtime.cwd, context.runtime.env)}`,
+		`${rail}  ${ui.accent(padDisplay("platform", keyWidth))}  ${ui.strong(platform)}`
+	];
+	if (result.project.url) {
+		lines.push(rail);
+		lines.push(`${rail}  ${ui.dim("→")} ${ui.link(result.project.url)}`);
+	}
+	return lines;
+}
+function formatLocalRepoPath(cwd, env) {
+	const resolved = path.resolve(cwd);
+	const home = env.HOME ? path.resolve(env.HOME) : null;
+	if (home && (resolved === home || resolved.startsWith(`${home}${path.sep}`))) {
+		const relative = path.relative(home, resolved);
+		return relative ? `~/${relative}` : "~";
 	}
+	return resolved;
 }
 function formatGitConnectionDetail(status) {
 	switch (status) {
@@ -124,4 +153,4 @@ function formatGitConnectionDetail(status) {
 	}
 }
 //#endregion
-export { renderGitConnect, renderGitDisconnect, renderProjectList, renderProjectShow, serializeProjectList, serializeProjectShow };
+export { renderGitConnect, renderGitDisconnect, renderProjectList, renderProjectSetup, renderProjectShow, serializeProjectList, serializeProjectSetup, serializeProjectShow };

package/dist/shell/command-arguments.js

@@ -0,0 +1,6 @@
+//#region src/shell/command-arguments.ts
+function formatCommandArgument(value) {
+	return /^[A-Za-z0-9._/-]+$/.test(value) && !value.startsWith("-") ? value : `'${value.replace(/'/g, "'\\''")}'`;
+}
+//#endregion
+export { formatCommandArgument };

package/dist/shell/command-meta.js

@@ -54,7 +54,11 @@ const DESCRIPTORS = [
 		id: "project",
 		path: ["prisma", "project"],
 		description: "Manage and inspect your Prisma projects",
-		examples: ["prisma-cli project list", "prisma-cli project show"]
+		examples: [
+			"prisma-cli project list",
+			"prisma-cli project link proj_123",
+			"prisma-cli project create my-app"
+		]
 	},
 	{
 		id: "app",
@@ -91,9 +95,33 @@ const DESCRIPTORS = [
 			"project",
 			"show"
 		],
-		description: "Show which project is active for this directory",
+		description: "Show this directory's Project binding",
 		examples: ["prisma-cli project show", "prisma-cli project show --project proj_123 --json"]
 	},
+	{
+		id: "project.create",
+		path: [
+			"prisma",
+			"project",
+			"create"
+		],
+		description: "Create a Project and link this directory",
+		examples: ["prisma-cli project create my-app", "prisma-cli project create my-app --json"]
+	},
+	{
+		id: "project.link",
+		path: [
+			"prisma",
+			"project",
+			"link"
+		],
+		description: "Link this directory to a Project",
+		examples: [
+			"prisma-cli project link",
+			"prisma-cli project link proj_123",
+			"prisma-cli project link \"Acme Dashboard\" --json"
+		]
+	},
 	{
 		id: "git.connect",
 		path: [
@@ -180,11 +208,16 @@ const DESCRIPTORS = [
 			"deploy"
 		],
 		description: "Creates a new deployment for the app",
+		longDescription: "Agent skills for guided Next.js deploys are available from the Prisma CLI skill cluster.",
 		examples: [
 			"prisma-cli app deploy",
+			"prisma-cli app deploy --project proj_123",
+			"prisma-cli app deploy --create-project my-app --yes",
 			"prisma-cli app deploy --app my-app --env DATABASE_URL=postgresql://example",
 			"prisma-cli app deploy --app my-app --framework nextjs --http-port 3000",
-			"prisma-cli app deploy --branch feat-login --framework hono"
+			"prisma-cli app deploy --branch feat-login --framework hono",
+			"pnpm dlx skills@latest add prisma/prisma-cli/skills#cli-v<cli-version> --all",
+			"prisma-cli app deploy --framework bun --entry src/server.ts"
 		]
 	},
 	{

package/dist/shell/command-runner.js

@@ -47,7 +47,8 @@ async function runStreamingCommand(runtime, commandName, options, handler) {
 			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
 			result: null,
 			warnings: [],
-			nextSteps: []
+			nextSteps: [],
+			nextActions: []
 		});
 	} catch (error) {
 		const cliError = toCliError(error);
@@ -58,7 +59,8 @@ async function runStreamingCommand(runtime, commandName, options, handler) {
 				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
 				error: cliErrorToJson(cliError),
 				warnings: [],
-				nextSteps: cliError.nextSteps
+				nextSteps: cliError.nextSteps,
+				nextActions: cliError.nextActions
 			});
 			else writeHumanError(context.output, context.ui, cliError, { trace: flags.trace });
 			process.exitCode = cliError.exitCode;

package/dist/shell/errors.js

@@ -12,6 +12,7 @@ var CliError = class extends Error {
 	docsUrl;
 	exitCode;
 	nextSteps;
+	nextActions;
 	humanLines;
 	constructor(options) {
 		super(options.summary);
@@ -28,6 +29,7 @@ var CliError = class extends Error {
 		this.docsUrl = options.docsUrl ?? null;
 		this.exitCode = options.exitCode ?? 1;
 		this.nextSteps = options.nextSteps ?? [];
+		this.nextActions = options.nextActions ?? [];
 		this.humanLines = options.humanLines && options.humanLines.length > 0 ? [...options.humanLines] : null;
 	}
 };