@spotpatch/shared 1.4.0 → 1.6.0

package/dist/index.js

@@ -124,9 +124,98 @@ var SPOTPATCH_LOCALE_PREFERENCES = Object.freeze([
   ...SPOTPATCH_LOCALES
 ]);
 
+// src/model/runtime-config.ts
+import { z } from "zod";
+
+// src/protocol/endpoints.ts
+var SPOTPATCH_API_BASE = "/__spotpatch/v1";
+var SPOTPATCH_TOKEN_HEADER = "X-SpotPatch-Token";
+var SPOTPATCH_ENDPOINTS = Object.freeze({
+  bootstrap: `${SPOTPATCH_API_BASE}/bootstrap`,
+  sourceContext: `${SPOTPATCH_API_BASE}/source-context`,
+  openEditor: `${SPOTPATCH_API_BASE}/open-editor`,
+  agentCapability: `${SPOTPATCH_API_BASE}/agent/capability`,
+  agentWorkspaceHealth: `${SPOTPATCH_API_BASE}/agent/workspace-health`,
+  agentJobs: `${SPOTPATCH_API_BASE}/agent/jobs`
+});
+function getAgentJobEndpoint(jobId, action) {
+  return `${SPOTPATCH_ENDPOINTS.agentJobs}/${encodeURIComponent(jobId)}/${action}`;
+}
+
 // src/model/editor.ts
 var SPOTPATCH_EDITOR_PREFERENCES = ["auto", "vscode", "cursor"];
 
+// src/model/runtime-config.ts
+var SPOTPATCH_NEXT_BUNDLERS = Object.freeze(["turbopack", "webpack"]);
+var SPOTPATCH_NEXT_ROUTER_KINDS = Object.freeze([
+  "app",
+  "pages",
+  "hybrid"
+]);
+var boundedText = (maximum) => z.string().trim().min(1).max(maximum);
+var profileIdSchema = z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u);
+var runtimeAiModelSchema = z.strictObject({
+  id: profileIdSchema,
+  label: boundedText(100)
+});
+var runtimeAiProviderSchema = z.strictObject({
+  id: profileIdSchema,
+  label: boundedText(100),
+  protocol: z.enum(["responses", "chat-completions"]),
+  models: z.array(runtimeAiModelSchema).min(1).max(64),
+  defaultModel: profileIdSchema
+}).refine(
+  ({ defaultModel, models }) => models.some(({ id }) => id === defaultModel) && new Set(models.map(({ id }) => id)).size === models.length,
+  { message: "Runtime AI model profiles are inconsistent." }
+);
+var runtimeAiConfigSchema = z.discriminatedUnion("enabled", [
+  z.strictObject({ enabled: z.literal(false) }),
+  z.strictObject({
+    enabled: z.literal(true),
+    providers: z.array(runtimeAiProviderSchema).min(1).max(32),
+    defaultProvider: profileIdSchema,
+    applyMode: z.enum(["review", "auto"])
+  }).refine(
+    ({ defaultProvider, providers }) => providers.some(({ id }) => id === defaultProvider) && new Set(providers.map(({ id }) => id)).size === providers.length,
+    { message: "Runtime AI provider profiles are inconsistent." }
+  )
+]);
+var positiveInteger = z.number().int().positive();
+var runtimeConfigBaseShape = {
+  apiBase: z.literal(SPOTPATCH_API_BASE),
+  ai: runtimeAiConfigSchema,
+  budget: z.strictObject({
+    totalCharacters: positiveInteger,
+    domCharacters: positiveInteger,
+    cssCharacters: positiveInteger,
+    codeCharacters: positiveInteger,
+    maxCodeLines: positiveInteger,
+    maxComponentDepth: positiveInteger
+  }),
+  debug: z.boolean(),
+  editor: z.enum(SPOTPATCH_EDITOR_PREFERENCES),
+  frameworkVersion: boundedText(64),
+  locale: z.enum(SPOTPATCH_LOCALE_PREFERENCES),
+  maxTargets: z.number().int().min(1).max(MAX_ANNOTATION_TARGETS),
+  redact: z.boolean(),
+  sessionId: z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u),
+  sessionToken: z.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/u),
+  shortcut: boundedText(128),
+  spotPatchVersion: boundedText(64)
+};
+var runtimeConfigSchema = z.discriminatedUnion("framework", [
+  z.strictObject({
+    ...runtimeConfigBaseShape,
+    framework: z.literal("vite")
+  }),
+  z.strictObject({
+    ...runtimeConfigBaseShape,
+    bundler: z.enum(SPOTPATCH_NEXT_BUNDLERS),
+    framework: z.literal("next"),
+    routerKind: z.enum(SPOTPATCH_NEXT_ROUTER_KINDS)
+  })
+]);
+
 // src/model/agent.ts
 var DEFAULT_AGENT_LIMITS = Object.freeze({
   maxTurns: 20,
@@ -208,102 +297,91 @@ function parseSourceMarker(value) {
   return Object.freeze({ fileId, line, column });
 }
 
-// src/protocol/endpoints.ts
-var SPOTPATCH_API_BASE = "/__spotpatch/v1";
-var SPOTPATCH_TOKEN_HEADER = "X-SpotPatch-Token";
-var SPOTPATCH_ENDPOINTS = Object.freeze({
-  sourceContext: `${SPOTPATCH_API_BASE}/source-context`,
-  openEditor: `${SPOTPATCH_API_BASE}/open-editor`,
-  agentCapability: `${SPOTPATCH_API_BASE}/agent/capability`,
-  agentWorkspaceHealth: `${SPOTPATCH_API_BASE}/agent/workspace-health`,
-  agentJobs: `${SPOTPATCH_API_BASE}/agent/jobs`
-});
-function getAgentJobEndpoint(jobId, action) {
-  return `${SPOTPATCH_ENDPOINTS.agentJobs}/${encodeURIComponent(jobId)}/${action}`;
-}
-
 // src/protocol/requests.ts
-import { z } from "zod";
-var sourceCoordinatesSchema = z.strictObject({
-  fileId: z.string().min(1).max(128),
-  line: z.number().int().positive(),
-  column: z.number().int().positive()
+import { z as z2 } from "zod";
+var runtimeBootstrapRequestSchema = z2.strictObject({});
+var sourceCoordinatesSchema = z2.strictObject({
+  fileId: z2.string().min(1).max(128),
+  line: z2.number().int().positive(),
+  column: z2.number().int().positive()
 });
 var sourceContextRequestSchema = sourceCoordinatesSchema.extend({
-  maxLines: z.number().int().positive()
+  maxLines: z2.number().int().positive()
 }).strict();
 var openEditorRequestSchema = sourceCoordinatesSchema.strict();
-var profileIdSchema = z.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
-var boundedString = (maximum) => z.string().max(maximum);
-var sourceRefSchema = z.strictObject({
+var profileIdSchema2 = z2.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+var boundedString = (maximum) => z2.string().max(maximum);
+var sourceRefSchema = z2.strictObject({
   fileId: boundedString(128).optional(),
   relativePath: boundedString(1024).optional(),
-  line: z.number().int().positive().optional(),
-  column: z.number().int().positive().optional(),
-  origin: z.enum(["jsx-host", "react-fiber", "dom-ancestor", "none"]),
-  confidence: z.enum(["exact", "probable", "approximate", "unknown"])
+  line: z2.number().int().positive().optional(),
+  column: z2.number().int().positive().optional(),
+  origin: z2.enum(["jsx-host", "react-fiber", "dom-ancestor", "none"]),
+  confidence: z2.enum(["exact", "probable", "approximate", "unknown"])
 });
-var matchedStyleRuleSchema = z.strictObject({
+var matchedStyleRuleSchema = z2.strictObject({
   selector: boundedString(2048),
   declarations: boundedString(8192),
   source: boundedString(1024).optional(),
   media: boundedString(1024).optional()
 });
-var codeContextSchema = z.strictObject({
+var codeContextSchema = z2.strictObject({
   relativePath: boundedString(1024),
-  language: z.enum(["tsx", "jsx"]),
-  startLine: z.number().int().positive(),
-  endLine: z.number().int().positive(),
+  language: z2.enum(["tsx", "jsx"]),
+  startLine: z2.number().int().positive(),
+  endLine: z2.number().int().positive(),
   excerpt: boundedString(16e3),
-  boundary: z.enum(["component", "nearby-lines"])
+  boundary: z2.enum(["component", "nearby-lines"])
 });
-var spotTargetContextRequestSchema = z.strictObject({
-  instruction: z.string().trim().min(1).max(MAX_TARGET_INSTRUCTION_CHARACTERS),
+var pageContextSchema = z2.strictObject({
+  url: boundedString(2048),
+  pathname: boundedString(2048),
+  title: boundedString(1024),
+  viewportWidth: z2.number().nonnegative(),
+  viewportHeight: z2.number().nonnegative(),
+  devicePixelRatio: z2.number().positive()
+});
+var spotTargetContextRequestSchema = z2.strictObject({
+  instruction: z2.string().trim().min(1).max(MAX_TARGET_INSTRUCTION_CHARACTERS),
+  page: pageContextSchema.optional(),
   source: sourceRefSchema,
-  react: z.strictObject({
-    supported: z.boolean(),
+  react: z2.strictObject({
+    supported: z2.boolean(),
     version: boundedString(64).optional(),
     componentName: boundedString(256).optional(),
-    componentStack: z.array(boundedString(256)).max(64),
+    componentStack: z2.array(boundedString(256)).max(64),
     source: sourceRefSchema.optional()
   }),
-  element: z.strictObject({
+  element: z2.strictObject({
     tagName: boundedString(128),
     selector: boundedString(2048),
     sanitizedHtml: boundedString(8192),
     textPreview: boundedString(2048).optional(),
     role: boundedString(256).optional(),
-    rect: z.strictObject({
-      x: z.number(),
-      y: z.number(),
-      width: z.number().nonnegative(),
-      height: z.number().nonnegative()
+    rect: z2.strictObject({
+      x: z2.number(),
+      y: z2.number(),
+      width: z2.number().nonnegative(),
+      height: z2.number().nonnegative()
     })
   }),
-  styles: z.strictObject({
-    classNames: z.array(boundedString(512)).max(256),
+  styles: z2.strictObject({
+    classNames: z2.array(boundedString(512)).max(256),
     inlineStyle: boundedString(8192).optional(),
-    matchedRules: z.array(matchedStyleRuleSchema).max(256),
-    computed: z.record(boundedString(256), boundedString(2048)),
-    warnings: z.array(boundedString(1024)).max(64)
+    matchedRules: z2.array(matchedStyleRuleSchema).max(256),
+    computed: z2.record(boundedString(256), boundedString(2048)),
+    warnings: z2.array(boundedString(1024)).max(64)
   }),
   code: codeContextSchema.optional(),
-  warnings: z.array(boundedString(1024)).max(64)
+  warnings: z2.array(boundedString(1024)).max(64)
 });
-var spotAnnotationRequestSchema = z.strictObject({
-  schemaVersion: z.literal(3),
+var spotAnnotationRequestSchema = z2.strictObject({
+  schemaVersion: z2.literal(3),
   id: boundedString(128),
-  locale: z.enum(SPOTPATCH_LOCALES),
-  page: z.strictObject({
-    url: boundedString(2048),
-    pathname: boundedString(2048),
-    title: boundedString(1024),
-    viewportWidth: z.number().nonnegative(),
-    viewportHeight: z.number().nonnegative(),
-    devicePixelRatio: z.number().positive()
-  }),
-  targets: z.array(spotTargetContextRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS),
-  createdAt: z.iso.datetime()
+  locale: z2.enum(SPOTPATCH_LOCALES),
+  page: pageContextSchema,
+  targets: z2.array(spotTargetContextRequestSchema).min(1).max(MAX_ANNOTATION_TARGETS),
+  createdAt: z2.iso.datetime()
 }).superRefine((annotation, context) => {
   const total = annotation.targets.reduce(
     (characters, target) => characters + target.instruction.length,
@@ -317,51 +395,51 @@ var spotAnnotationRequestSchema = z.strictObject({
     });
   }
 });
-var agentCapabilityRequestSchema = z.strictObject({
-  providerProfileId: profileIdSchema,
-  modelProfileId: profileIdSchema
+var agentCapabilityRequestSchema = z2.strictObject({
+  providerProfileId: profileIdSchema2,
+  modelProfileId: profileIdSchema2
 });
-var agentWorkspaceHealthRequestSchema = z.strictObject({});
-var agentJobCreateRequestSchema = z.strictObject({
+var agentWorkspaceHealthRequestSchema = z2.strictObject({});
+var agentJobCreateRequestSchema = z2.strictObject({
   annotation: spotAnnotationRequestSchema,
-  providerProfileId: profileIdSchema,
-  modelProfileId: profileIdSchema,
-  providerDataConsent: z.literal(true),
-  workingTreeMode: z.enum(["require-clean", "include-local-changes"]).default("require-clean")
+  providerProfileId: profileIdSchema2,
+  modelProfileId: profileIdSchema2,
+  providerDataConsent: z2.literal(true),
+  workingTreeMode: z2.enum(["require-clean", "include-local-changes"]).default("require-clean")
 });
-var agentJobActionRequestSchema = z.strictObject({});
+var agentJobActionRequestSchema = z2.strictObject({});
 
 // src/protocol/agent-schemas.ts
-import { z as z2 } from "zod";
-var profileIdSchema2 = z2.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
-var boundedString2 = (maximum) => z2.string().max(maximum);
-var errorCodeSchema = z2.enum(ERROR_CODES);
-var agentCapabilitySnapshotSchema = z2.strictObject({
-  providerProfileId: profileIdSchema2,
+import { z as z3 } from "zod";
+var profileIdSchema3 = z3.string().min(1).max(64).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+var boundedString2 = (maximum) => z3.string().max(maximum);
+var errorCodeSchema = z3.enum(ERROR_CODES);
+var agentCapabilitySnapshotSchema = z3.strictObject({
+  providerProfileId: profileIdSchema3,
   providerLabel: boundedString2(100),
-  modelProfileId: profileIdSchema2,
+  modelProfileId: profileIdSchema3,
   modelLabel: boundedString2(100),
-  protocol: z2.enum(["responses", "chat-completions"]),
-  state: z2.enum(AGENT_CAPABILITY_STATES),
-  authenticated: z2.boolean(),
-  modelAvailable: z2.boolean(),
-  toolCalling: z2.boolean(),
-  toolResultContinuation: z2.boolean(),
-  streaming: z2.boolean(),
-  checkedAt: z2.iso.datetime().optional(),
+  protocol: z3.enum(["responses", "chat-completions"]),
+  state: z3.enum(AGENT_CAPABILITY_STATES),
+  authenticated: z3.boolean(),
+  modelAvailable: z3.boolean(),
+  toolCalling: z3.boolean(),
+  toolResultContinuation: z3.boolean(),
+  streaming: z3.boolean(),
+  checkedAt: z3.iso.datetime().optional(),
   errorCode: errorCodeSchema.optional()
 });
-var agentWorkspaceHealthSnapshotSchema = z2.strictObject({
-  state: z2.enum(AGENT_WORKSPACE_STATES),
-  checkedAt: z2.iso.datetime(),
-  changes: z2.strictObject({
-    staged: z2.number().int().nonnegative(),
-    unstaged: z2.number().int().nonnegative(),
-    untracked: z2.number().int().nonnegative(),
-    conflicted: z2.number().int().nonnegative(),
-    total: z2.number().int().nonnegative()
+var agentWorkspaceHealthSnapshotSchema = z3.strictObject({
+  state: z3.enum(AGENT_WORKSPACE_STATES),
+  checkedAt: z3.iso.datetime(),
+  changes: z3.strictObject({
+    staged: z3.number().int().nonnegative(),
+    unstaged: z3.number().int().nonnegative(),
+    untracked: z3.number().int().nonnegative(),
+    conflicted: z3.number().int().nonnegative(),
+    total: z3.number().int().nonnegative()
   }),
-  canIncludeLocalChanges: z2.boolean(),
+  canIncludeLocalChanges: z3.boolean(),
   errorCode: errorCodeSchema.optional()
 }).refine(
   ({ state, changes, canIncludeLocalChanges, errorCode }) => {
@@ -379,42 +457,42 @@ var agentWorkspaceHealthSnapshotSchema = z2.strictObject({
   },
   { message: "Agent workspace health fields are inconsistent." }
 );
-var agentChangedFileSchema = z2.strictObject({
+var agentChangedFileSchema = z3.strictObject({
   relativePath: boundedString2(1024),
-  kind: z2.enum(AGENT_FILE_CHANGE_KINDS),
-  additions: z2.number().int().nonnegative(),
-  deletions: z2.number().int().nonnegative()
+  kind: z3.enum(AGENT_FILE_CHANGE_KINDS),
+  additions: z3.number().int().nonnegative(),
+  deletions: z3.number().int().nonnegative()
 });
-var agentCheckResultSchema = z2.strictObject({
-  checkId: profileIdSchema2,
+var agentCheckResultSchema = z3.strictObject({
+  checkId: profileIdSchema3,
   label: boundedString2(100),
-  status: z2.enum(AGENT_CHECK_STATUSES),
-  durationMs: z2.number().int().nonnegative(),
+  status: z3.enum(AGENT_CHECK_STATUSES),
+  durationMs: z3.number().int().nonnegative(),
   output: boundedString2(8e4)
 });
-var agentJobSnapshotSchema = z2.strictObject({
-  jobId: z2.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
-  status: z2.enum(AGENT_JOB_STATUSES),
-  providerProfileId: profileIdSchema2,
+var agentJobSnapshotSchema = z3.strictObject({
+  jobId: z3.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+  status: z3.enum(AGENT_JOB_STATUSES),
+  providerProfileId: profileIdSchema3,
   providerLabel: boundedString2(100),
-  modelProfileId: profileIdSchema2,
+  modelProfileId: profileIdSchema3,
   modelLabel: boundedString2(100),
   phaseMessage: boundedString2(1024),
-  createdAt: z2.iso.datetime(),
-  updatedAt: z2.iso.datetime(),
-  canCancel: z2.boolean(),
-  canApply: z2.boolean(),
-  canRevert: z2.boolean(),
+  createdAt: z3.iso.datetime(),
+  updatedAt: z3.iso.datetime(),
+  canCancel: z3.boolean(),
+  canApply: z3.boolean(),
+  canRevert: z3.boolean(),
   errorCode: errorCodeSchema.optional()
 });
-var agentJobResultSchema = z2.strictObject({
-  jobId: z2.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+var agentJobResultSchema = z3.strictObject({
+  jobId: z3.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
   summary: boundedString2(8e4),
   diff: boundedString2(1e6),
-  files: z2.array(agentChangedFileSchema).max(100),
-  checks: z2.array(agentCheckResultSchema).max(100)
+  files: z3.array(agentChangedFileSchema).max(100),
+  checks: z3.array(agentCheckResultSchema).max(100)
 });
-var agentJobResultResponseSchema = z2.strictObject({
+var agentJobResultResponseSchema = z3.strictObject({
   snapshot: agentJobSnapshotSchema,
   result: agentJobResultSchema.optional()
 }).superRefine((value, context) => {
@@ -426,44 +504,44 @@ var agentJobResultResponseSchema = z2.strictObject({
     });
   }
 });
-var agentJobEventBaseSchema = z2.strictObject({
-  schemaVersion: z2.literal(2),
-  sequence: z2.number().int().positive(),
-  jobId: z2.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
-  status: z2.enum(AGENT_JOB_STATUSES),
-  timestamp: z2.iso.datetime()
+var agentJobEventBaseSchema = z3.strictObject({
+  schemaVersion: z3.literal(2),
+  sequence: z3.number().int().positive(),
+  jobId: z3.string().min(22).max(128).regex(/^[A-Za-z0-9_-]+$/),
+  status: z3.enum(AGENT_JOB_STATUSES),
+  timestamp: z3.iso.datetime()
 });
-var agentJobEventSchema = z2.discriminatedUnion("type", [
+var agentJobEventSchema = z3.discriminatedUnion("type", [
   agentJobEventBaseSchema.extend({
-    type: z2.literal("snapshot"),
-    data: z2.strictObject({ snapshot: agentJobSnapshotSchema })
+    type: z3.literal("snapshot"),
+    data: z3.strictObject({ snapshot: agentJobSnapshotSchema })
   }),
   agentJobEventBaseSchema.extend({
-    type: z2.literal("phase"),
-    data: z2.strictObject({ message: boundedString2(1024) })
+    type: z3.literal("phase"),
+    data: z3.strictObject({ message: boundedString2(1024) })
   }),
   agentJobEventBaseSchema.extend({
-    type: z2.literal("tool"),
-    data: z2.strictObject({
-      turn: z2.number().int().positive(),
+    type: z3.literal("tool"),
+    data: z3.strictObject({
+      turn: z3.number().int().positive(),
       toolCallId: boundedString2(256),
       toolName: boundedString2(100),
-      state: z2.enum(["started", "succeeded", "failed"]),
+      state: z3.enum(["started", "succeeded", "failed"]),
       relativePath: boundedString2(1024).optional(),
       checkLabel: boundedString2(100).optional()
     })
   }),
   agentJobEventBaseSchema.extend({
-    type: z2.literal("check"),
-    data: z2.strictObject({ result: agentCheckResultSchema })
+    type: z3.literal("check"),
+    data: z3.strictObject({ result: agentCheckResultSchema })
   }),
   agentJobEventBaseSchema.extend({
-    type: z2.literal("result-ready"),
-    data: z2.strictObject({ hasResult: z2.literal(true) })
+    type: z3.literal("result-ready"),
+    data: z3.strictObject({ hasResult: z3.literal(true) })
   }),
   agentJobEventBaseSchema.extend({
-    type: z2.literal("error"),
-    data: z2.strictObject({
+    type: z3.literal("error"),
+    data: z3.strictObject({
       code: errorCodeSchema,
       message: boundedString2(1024)
     })
@@ -508,6 +586,8 @@ export {
   SPOTPATCH_ENDPOINTS,
   SPOTPATCH_LOCALES,
   SPOTPATCH_LOCALE_PREFERENCES,
+  SPOTPATCH_NEXT_BUNDLERS,
+  SPOTPATCH_NEXT_ROUTER_KINDS,
   SPOTPATCH_REPOSITORY_URL,
   SPOTPATCH_TOKEN_HEADER,
   SpotPatchError,
@@ -529,6 +609,8 @@ export {
   openEditorRequestSchema,
   parseSourceMarker,
   redactSensitiveText,
+  runtimeBootstrapRequestSchema,
+  runtimeConfigSchema,
   sanitizeUrl,
   sourceContextRequestSchema,
   spotAnnotationRequestSchema,