@usepipr/sdk 0.4.3 → 0.5.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as configFactoryBrand, i as builtinReadOnlyToolBrand, o as assertSupportedCommandRestCapture, r as renderPromptValue } from "./config-Ct0Qfa_b.mjs";
+import { a as configFactoryBrand, i as serializePromptJson, o as assertSupportedCommandRestCapture, r as renderPromptValue } from "./config-STm6gTIf.mjs";
 import { z, z as z$1 } from "zod";
 //#region src/prompt.ts
 /** Creates trimmed Markdown from a template literal with common indentation removed. */
@@ -18,6 +18,110 @@ function stripCommonIndent(value) {
 	return lines.map((line) => line.slice(indent)).join("\n");
 }
 //#endregion
+//#region src/runtime-handles.ts
+const taskRecords = /* @__PURE__ */ new WeakMap();
+const agentRecords = /* @__PURE__ */ new WeakMap();
+const toolRecords = /* @__PURE__ */ new WeakMap();
+function createTaskHandle(definition) {
+	const handle = {
+		kind: "pipr.task",
+		name: definition.name
+	};
+	const record = {
+		name: definition.name,
+		check: definition.check,
+		...definition.local === false ? { local: false } : {},
+		handler: definition.run
+	};
+	taskRecords.set(handle, record);
+	return {
+		handle,
+		record
+	};
+}
+function runtimeTaskForHandle(task) {
+	const record = taskRecords.get(task);
+	if (!record) throw new Error("Expected a task handle created by pipr.task");
+	return record;
+}
+function createAgentHandle(definition) {
+	const handle = {
+		kind: "pipr.agent",
+		name: definition.name,
+		extend(patch) {
+			return createAgentHandle({
+				...definition,
+				...patch,
+				instructions: patch.instructions === void 0 ? definition.instructions : {
+					kind: "pipr.prompt",
+					value: `${renderPromptValue(definition.instructions)}\n\n${renderPromptValue(patch.instructions)}`.trim()
+				}
+			}).handle;
+		}
+	};
+	const record = {
+		name: definition.name,
+		definition: runtimeAgentDefinition(definition)
+	};
+	agentRecords.set(handle, record);
+	return {
+		handle,
+		record
+	};
+}
+function runtimeAgentForHandle(agent) {
+	const record = agentRecords.get(agent);
+	if (!record) throw new Error("Expected an agent handle created by pipr.agent");
+	return record;
+}
+function createToolHandle(definition) {
+	const handle = {
+		kind: "pipr.tool",
+		name: definition.name
+	};
+	const record = {
+		name: definition.name,
+		description: definition.description,
+		input: definition.input,
+		output: definition.output,
+		run: definition.run,
+		toModelOutput: definition.toModelOutput
+	};
+	toolRecords.set(handle, record);
+	return {
+		handle,
+		record
+	};
+}
+function createBuiltinReadOnlyToolHandle() {
+	const handle = {
+		kind: "pipr.tool",
+		name: "readOnly"
+	};
+	const record = {
+		name: "readOnly",
+		builtinReadOnly: true
+	};
+	toolRecords.set(handle, record);
+	return {
+		handle,
+		record
+	};
+}
+function runtimeToolForHandle(tool) {
+	const record = toolRecords.get(tool);
+	if (!record) throw new Error("Expected a tool handle created by pipr.tool");
+	return record;
+}
+function runtimeAgentDefinition(definition) {
+	return {
+		...definition,
+		prompt: definition.prompt,
+		output: definition.output,
+		tools: definition.tools?.map(runtimeToolForHandle)
+	};
+}
+//#endregion
 //#region src/review-contract.ts
 const nonEmptyStringSchema = z$1.string().min(1);
 const positiveIntegerSchema = z$1.number().int().positive();
@@ -173,20 +277,17 @@ function createBuilder() {
 	const commands = [];
 	const tools = [];
 	const publication = {};
+	const readOnlyTool = createBuiltinReadOnlyToolHandle();
 	let checks;
 	let limits;
 	const api = {
-		tools: { readOnly: [{
-			kind: "pipr.tool",
-			name: "readOnly",
-			[builtinReadOnlyToolBrand]: true
-		}] },
+		tools: { readOnly: [readOnlyTool.handle] },
 		schemas,
 		on: { changeRequest(options) {
 			if (!Array.isArray(options.actions) || !options.task) throw new Error("pipr.on.changeRequest requires { actions, task }");
 			changeRequestTriggers.push({
 				actions: [...options.actions],
-				task: options.task
+				task: runtimeTaskForHandle(options.task)
 			});
 		} },
 		secret(options) {
@@ -212,21 +313,15 @@ function createBuilder() {
 			return profile;
 		},
 		agent(definition) {
-			const agent = createAgent(definition);
-			agents.push(agent);
-			return agent;
+			const agent = createAgentHandle(definition);
+			agents.push(agent.record);
+			return agent.handle;
 		},
 		task(definition) {
 			if (!definition.name || typeof definition.run !== "function") throw new Error("pipr.task requires { name, run }");
-			const task = {
-				kind: "pipr.task",
-				name: definition.name,
-				check: definition.check,
-				...definition.local === false ? { local: false } : {},
-				handler: definition.run
-			};
-			tasks.push(task);
-			return task;
+			const task = createTaskHandle(definition);
+			tasks.push(task.record);
+			return task.handle;
 		},
 		reviewer(options) {
 			return createReviewer(api, options);
@@ -253,7 +348,7 @@ function createBuilder() {
 				permission: options.permission ?? "write",
 				description: options.description,
 				parse: options.parse,
-				task: options.task
+				task: runtimeTaskForHandle(options.task)
 			});
 		},
 		use(plugin) {
@@ -263,13 +358,12 @@ function createBuilder() {
 			if (definition.name === "readOnly") throw new Error("Tool name 'readOnly' is reserved for pipr built-in tools");
 			const run = definition.run;
 			if (!run) throw new Error(`Tool '${definition.name}' must define run`);
-			const tool = {
-				kind: "pipr.tool",
+			const tool = createToolHandle({
 				...definition,
 				run
-			};
-			tools.push(tool);
-			return tool;
+			});
+			tools.push(tool.record);
+			return tool.handle;
 		},
 		schema,
 		jsonSchema,
@@ -291,7 +385,7 @@ function createBuilder() {
 			};
 		},
 		json(value, options) {
-			const text = JSON.stringify(value, null, options?.pretty === false ? 0 : 2);
+			const text = serializePromptJson(value, options?.pretty !== false);
 			if (options?.maxCharacters !== void 0 && text.length > options.maxCharacters) throw new Error(`JSON prompt value exceeded ${options.maxCharacters} characters`);
 			return {
 				kind: "pipr.prompt",
@@ -306,6 +400,7 @@ function createBuilder() {
 			assertUnique(commands.map((command) => command.pattern), "command");
 			assertModelIdentity(models);
 			return {
+				resolveAgent: runtimeAgentForHandle,
 				models,
 				agents,
 				tasks,
@@ -469,6 +564,7 @@ function createReviewRecipeTask(api, id, agent, options) {
 			});
 			const source = typeof options.comment === "function" ? await options.comment(result, {
 				review: { id },
+				run: context.run,
 				repository: context.repository,
 				change: context.change,
 				platform: context.platform
@@ -558,23 +654,6 @@ function assertDiffManifestLimitConflicts(current, next) {
 		for (const [key, value] of Object.entries(next.diffManifest)) if (value !== void 0 && current.diffManifest[key] !== void 0 && current.diffManifest[key] !== value) throw new Error(`pipr.config limits.diffManifest.${key} conflicts with existing value`);
 	}
 }
-function createAgent(definition) {
-	return {
-		kind: "pipr.agent",
-		name: definition.name,
-		definition,
-		extend(patch) {
-			return createAgent({
-				...definition,
-				...patch,
-				instructions: patch.instructions === void 0 ? definition.instructions : {
-					kind: "pipr.prompt",
-					value: `${renderPromptValue(definition.instructions)}\n\n${renderPromptValue(patch.instructions)}`.trim()
-				}
-			});
-		}
-	};
-}
 function assertUnique(values, label) {
 	const seen = /* @__PURE__ */ new Set();
 	for (const value of values) {
@@ -629,6 +708,128 @@ function stableJsonValue(value) {
 	return value;
 }
 //#endregion
-export { defaultReviewActions, defaultReviewEntrypoints, definePipr, definePlugin, jsonSchema, md, parseReviewFinding, parseReviewResult, parseReviewSummary, reviewFindingSchema, reviewResultSchema, reviewSchemaExample, reviewSummarySchema, schema, schemas, z };
+//#region src/result.ts
+const piprRunTriggers = [
+	"change-request",
+	"command",
+	"verifier",
+	"local"
+];
+const text = z$1.string().min(1);
+const count = z$1.number().int().nonnegative();
+const header = { formatVersion: z$1.literal(2) };
+const runSummarySchema = z$1.strictObject({
+	id: text.max(200),
+	trigger: z$1.enum(piprRunTriggers),
+	baseSha: text.max(200),
+	headSha: text.max(200),
+	tasks: z$1.array(text.max(200)).max(200),
+	durationMs: count,
+	models: z$1.array(text.max(200)).max(20),
+	agentRuns: count,
+	inputTokens: count,
+	outputTokens: count,
+	costUsd: z$1.number().nonnegative().finite(),
+	usageStatus: z$1.enum([
+		"complete",
+		"partial",
+		"unavailable"
+	])
+});
+const inlineCountsSchema = z$1.strictObject({
+	posted: count,
+	skipped: count,
+	failed: count
+});
+const publicationCountsSchema = z$1.strictObject({
+	inlineComments: inlineCountsSchema,
+	inlinePublicationErrorCount: count,
+	inlineResolutionErrorCount: count
+});
+const reviewPublicationSchema = z$1.discriminatedUnion("state", [z$1.strictObject({ state: z$1.literal("disabled") }), z$1.strictObject({
+	state: z$1.literal("completed"),
+	mainComment: z$1.strictObject({ action: z$1.enum(["created", "updated"]) }),
+	...publicationCountsSchema.shape
+})]);
+const schemas$1 = [
+	z$1.strictObject({
+		...header,
+		kind: z$1.literal("review"),
+		run: runSummarySchema,
+		mainComment: z$1.string(),
+		inlineFindings: z$1.array(reviewFindingSchema),
+		droppedFindings: z$1.array(z$1.strictObject({
+			finding: reviewFindingSchema,
+			reason: text
+		})),
+		taskChecks: z$1.array(z$1.strictObject({
+			taskName: text,
+			conclusion: z$1.enum([
+				"success",
+				"failure",
+				"neutral"
+			]),
+			summary: text.optional()
+		})),
+		repairAttempted: z$1.boolean(),
+		publication: reviewPublicationSchema
+	}),
+	z$1.strictObject({
+		...header,
+		kind: z$1.literal("skipped"),
+		reason: text
+	}),
+	z$1.strictObject({
+		...header,
+		kind: z$1.literal("ignored"),
+		reason: text
+	}),
+	z$1.strictObject({
+		...header,
+		kind: z$1.literal("dry-run")
+	}),
+	z$1.strictObject({
+		...header,
+		kind: z$1.literal("command-help"),
+		reason: text,
+		mainComment: z$1.string()
+	}),
+	z$1.strictObject({
+		...header,
+		kind: z$1.literal("command-response"),
+		run: runSummarySchema,
+		mainComment: z$1.string(),
+		publication: z$1.strictObject({
+			state: z$1.literal("completed"),
+			action: z$1.enum(["created", "updated"])
+		})
+	}),
+	z$1.strictObject({
+		...header,
+		kind: z$1.literal("verifier"),
+		run: runSummarySchema,
+		publication: z$1.strictObject({
+			state: z$1.literal("completed"),
+			inlineResolutionErrorCount: count
+		})
+	}),
+	z$1.strictObject({
+		...header,
+		kind: z$1.literal("publication-error"),
+		message: text,
+		publication: publicationCountsSchema.optional()
+	}),
+	z$1.strictObject({
+		...header,
+		kind: z$1.literal("error"),
+		message: text
+	})
+];
+const piprResultSchema = z$1.discriminatedUnion("kind", schemas$1);
+function parsePiprResult(value) {
+	return piprResultSchema.parse(value);
+}
+//#endregion
+export { defaultReviewActions, defaultReviewEntrypoints, definePipr, definePlugin, jsonSchema, md, parsePiprResult, parseReviewFinding, parseReviewResult, parseReviewSummary, piprResultSchema, reviewFindingSchema, reviewResultSchema, reviewSchemaExample, reviewSummarySchema, schema, schemas, z };
 
 //# sourceMappingURL=index.mjs.map