@spotpatch/vite 1.4.4 → 1.6.0

package/README.md

@@ -25,9 +25,16 @@ npm install --save-dev @spotpatch/vite
 pnpm add -D @spotpatch/vite
 ```
 
-### Configure
+### Initialize
 
-Place SpotPatch before the React plugin so its development source transform runs first.
+Run the safe, idempotent initializer and its read-only diagnostic:
+
+```bash
+pnpm exec spotpatch-vite init
+pnpm exec spotpatch-vite check
+```
+
+The initializer places SpotPatch before the React plugin. When the project has a local TypeScript installation and root `tsconfig.json`, it also exposes the in-page Review / Trusted fast selector without duplicating provider configuration:
 
 ```ts
 // vite.config.ts
@@ -36,7 +43,7 @@ import react from "@vitejs/plugin-react-swc";
 import { defineConfig } from "vite";
 
 export default defineConfig({
-  plugins: [spotPatch(), react()],
+  plugins: [spotPatch({ trustedFastMode: true }), react()],
 });
 ```
 
@@ -75,20 +82,21 @@ spotPatch({
 });
 ```
 
-| Option       | Default                                           | Description                                                             |
-| ------------ | ------------------------------------------------- | ----------------------------------------------------------------------- |
-| `enabled`    | `true`                                            | Enables the development plugin.                                         |
-| `include`    | JSX/TSX under `src`                               | Files eligible for source marker injection.                             |
-| `exclude`    | dependencies, tests, stories and generated output | Files excluded from transformation.                                     |
-| `editor`     | `"auto"`                                          | Auto-detect Cursor or VS Code; either can be fixed explicitly.          |
-| `redact`     | `true`                                            | Sanitizes collected context; mandatory secret classes remain protected. |
-| `budget`     | bounded defaults                                  | Limits total, DOM, CSS and source context sizes.                        |
-| `shortcut`   | `"Mod+Shift+S"`                                   | Toggles element selection.                                              |
-| `allowLan`   | `false`                                           | Keeps Host and Origin authorization loopback-only by default.           |
-| `debug`      | `false`                                           | Enables development diagnostics without logging credentials.            |
-| `locale`     | `"auto"`                                          | Resolves `en-US` or `zh-CN`.                                            |
-| `maxTargets` | `8`                                               | Targets allowed in one change request by default.                       |
-| `ai`         | disabled or a detected complete environment       | Optional provider and Agent settings.                                   |
+| Option            | Default                                           | Description                                                             |
+| ----------------- | ------------------------------------------------- | ----------------------------------------------------------------------- |
+| `enabled`         | `true`                                            | Enables the development plugin.                                         |
+| `include`         | JSX/TSX under `src`                               | Files eligible for source marker injection.                             |
+| `exclude`         | dependencies, tests, stories and generated output | Files excluded from transformation.                                     |
+| `editor`          | `"auto"`                                          | Auto-detect Cursor or VS Code; either can be fixed explicitly.          |
+| `redact`          | `true`                                            | Sanitizes collected context; mandatory secret classes remain protected. |
+| `budget`          | bounded defaults                                  | Limits total, DOM, CSS and source context sizes.                        |
+| `shortcut`        | `"Mod+Shift+S"`                                   | Toggles element selection.                                              |
+| `allowLan`        | `false`                                           | Keeps Host and Origin authorization loopback-only by default.           |
+| `debug`           | `false`                                           | Enables development diagnostics without logging credentials.            |
+| `locale`          | `"auto"`                                          | Resolves `en-US` or `zh-CN`.                                            |
+| `maxTargets`      | `8`                                               | Targets allowed in one change request by default.                       |
+| `ai`              | disabled or a detected complete environment       | Optional provider and Agent settings.                                   |
+| `trustedFastMode` | `false`                                           | Exposes the page selector and auto-discovers a local TypeScript check.  |
 
 The package exports the option types, AI provider types, Agent limits, and immutable defaults. See the [public API specification](https://github.com/huanglvjing/spotpatch/blob/main/docs/%E6%8A%80%E6%9C%AF%E6%96%B9%E6%A1%88/03-%E5%85%AC%E5%85%B1API%E4%B8%8E%E6%95%B0%E6%8D%AE%E6%A8%A1%E5%9E%8B.md) for the complete constraints.
 
@@ -119,7 +127,15 @@ spotPatch({
 });
 ```
 
-The default Agent path is review-gated: **Check environment** provides an optional source-free capability diagnostic, while Run starts the real isolated tool session directly and proves tool continuation inline. The Agent supplies bounded nearby project conventions, exposes file tools rather than an arbitrary shell, reuses current host-run checks, and shows the complete Diff before Apply. SpotPatch does not commit, push, publish, or deploy application code.
+The default Agent path is review-gated: **Check environment** provides an optional source-free capability diagnostic, while Run starts the real isolated tool session directly and proves tool continuation inline. The Agent supplies bounded nearby project conventions, exposes file tools rather than an arbitrary shell, reuses current host-run checks, and shows the complete Diff before Apply.
+
+`spotpatch-vite init` automatically enables the page selector when it can discover a local TypeScript check. The equivalent concise manual option is:
+
+```ts
+spotPatch({ trustedFastMode: true });
+```
+
+The page defaults to Review; choosing Trusted fast replaces the provider and dirty-worktree confirmations with one session-scoped consent and directly applies changes after required checks. Advanced projects can still configure explicit checks through `ai.execution`. This mode can directly apply validated file deletions and restart-sensitive configuration changes. It does not allow credentials, environment files, Git metadata, external paths, arbitrary shell, failed checks, or baseline conflicts. SpotPatch does not commit, push, publish, or deploy application code.
 
 ### Security and production behavior
 
@@ -161,9 +177,16 @@ npm install --save-dev @spotpatch/vite
 pnpm add -D @spotpatch/vite
 ```
 
-### 配置
+### 初始化
 
-SpotPatch 必须放在 React 插件之前，让开发期源码转换先执行。
+运行安全、幂等的初始化命令，再执行只读诊断：
+
+```bash
+pnpm exec spotpatch-vite init
+pnpm exec spotpatch-vite check
+```
+
+初始化器会把 SpotPatch 放在 React 插件之前；项目存在本地 TypeScript 与根 `tsconfig.json` 时，还会自动开放页面内的“审阅 / 可信快速”选择，不需要重复填写 Provider：
 
 ```ts
 // vite.config.ts
@@ -172,7 +195,7 @@ import react from "@vitejs/plugin-react-swc";
 import { defineConfig } from "vite";
 
 export default defineConfig({
-  plugins: [spotPatch(), react()],
+  plugins: [spotPatch({ trustedFastMode: true }), react()],
 });
 ```
 
@@ -211,20 +234,21 @@ spotPatch({
 });
 ```
 
-| 选项         | 默认值                       | 说明                                                 |
-| ------------ | ---------------------------- | ---------------------------------------------------- |
-| `enabled`    | `true`                       | 启用开发期插件。                                     |
-| `include`    | `src` 下 JSX/TSX             | 允许注入源码标记的文件。                             |
-| `exclude`    | 依赖、测试、Story 与生成目录 | 不进行转换的文件。                                   |
-| `editor`     | `"auto"`                     | 自动识别 Cursor 或 VS Code，也可显式固定。           |
-| `redact`     | `true`                       | 清洗采集上下文；强制保护的秘密类型不会因关闭而暴露。 |
-| `budget`     | 有界默认值                   | 限制总量、DOM、CSS 和源码上下文大小。                |
-| `shortcut`   | `"Mod+Shift+S"`              | 切换元素选择器。                                     |
-| `allowLan`   | `false`                      | 默认只允许 loopback Host 与 Origin。                 |
-| `debug`      | `false`                      | 输出不包含凭据的开发诊断。                           |
-| `locale`     | `"auto"`                     | 自动解析 `en-US` 或 `zh-CN`。                        |
-| `maxTargets` | `8`                          | 一次修改任务默认允许的目标数。                       |
-| `ai`         | 关闭或检测到完整环境配置     | 可选 Provider 和 Agent 配置。                        |
+| 选项              | 默认值                       | 说明                                                 |
+| ----------------- | ---------------------------- | ---------------------------------------------------- |
+| `enabled`         | `true`                       | 启用开发期插件。                                     |
+| `include`         | `src` 下 JSX/TSX             | 允许注入源码标记的文件。                             |
+| `exclude`         | 依赖、测试、Story 与生成目录 | 不进行转换的文件。                                   |
+| `editor`          | `"auto"`                     | 自动识别 Cursor 或 VS Code，也可显式固定。           |
+| `redact`          | `true`                       | 清洗采集上下文；强制保护的秘密类型不会因关闭而暴露。 |
+| `budget`          | 有界默认值                   | 限制总量、DOM、CSS 和源码上下文大小。                |
+| `shortcut`        | `"Mod+Shift+S"`              | 切换元素选择器。                                     |
+| `allowLan`        | `false`                      | 默认只允许 loopback Host 与 Origin。                 |
+| `debug`           | `false`                      | 输出不包含凭据的开发诊断。                           |
+| `locale`          | `"auto"`                     | 自动解析 `en-US` 或 `zh-CN`。                        |
+| `maxTargets`      | `8`                          | 一次修改任务默认允许的目标数。                       |
+| `ai`              | 关闭或检测到完整环境配置     | 可选 Provider 和 Agent 配置。                        |
+| `trustedFastMode` | `false`                      | 开放页面模式选择并自动发现本地 TypeScript 校验。     |
 
 本包导出选项类型、AI Provider 类型、Agent 限制和不可变默认值。完整约束见[公共 API 规范](https://github.com/huanglvjing/spotpatch/blob/main/docs/%E6%8A%80%E6%9C%AF%E6%96%B9%E6%A1%88/03-%E5%85%AC%E5%85%B1API%E4%B8%8E%E6%95%B0%E6%8D%AE%E6%A8%A1%E5%9E%8B.md)。
 
@@ -255,7 +279,15 @@ spotPatch({
 });
 ```
 
-默认 Agent 路径必须经过审阅：“检查运行环境”提供不含源码的可选能力诊断；点击运行会直接进入真实隔离工具会话，并在会话内证明工具续接能力。Agent 会提供有界的就近项目规范，只暴露文件工具而不是任意 Shell，复用当前变更版本中由宿主实际执行的检查，并在 Apply 前展示完整 Diff。SpotPatch 不会替业务代码执行 commit、push、发包或部署。
+默认 Agent 路径必须经过审阅：“检查运行环境”提供不含源码的可选能力诊断；点击运行会直接进入真实隔离工具会话，并在会话内证明工具续接能力。Agent 会提供有界的就近项目规范，只暴露文件工具而不是任意 Shell，复用当前变更版本中由宿主实际执行的检查，并在 Apply 前展示完整 Diff。
+
+`spotpatch-vite init` 能发现本地 TypeScript 校验时会自动开放页面选择；等价的简洁手动配置只有一行：
+
+```ts
+spotPatch({ trustedFastMode: true });
+```
+
+页面默认保持审阅模式；用户选择“可信快速”后，面板才会把 Provider 与脏工作区确认合并成一次会话级授权，并在必需检查通过后直接应用。高级项目仍可通过 `ai.execution` 配置自己的检查。该模式可以直接应用验证通过的文件删除与需要重启开发服务的配置变更，但不会开放凭据、环境文件、Git 元数据、项目外路径、任意 Shell，也不会绕过失败检查或基线冲突。SpotPatch 不会替业务代码执行 commit、push、发包或部署。
 
 ### 安全与生产行为
 

package/dist/cli.js

@@ -0,0 +1,494 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFile } from "fs/promises";
+import { createRequire } from "module";
+import path2 from "path";
+
+// src/initializer.ts
+import path from "path";
+import {
+  applyIntegrationPlan,
+  createIntegrationFileChange,
+  discoverProjectValidationCheck,
+  integrationPathExists,
+  readIntegrationFile
+} from "@spotpatch/dev-server";
+import { DEFAULT_AGENT_LIMITS } from "@spotpatch/shared";
+import { MagicString } from "magic-string";
+import {
+  parseSync,
+  Visitor
+} from "oxc-parser";
+var ADAPTER_PACKAGE_NAME = "@spotpatch/vite";
+var CONFIG_FILE_NAMES = Object.freeze([
+  "vite.config.ts",
+  "vite.config.mts",
+  "vite.config.js",
+  "vite.config.mjs"
+]);
+function isParserErrorSeverity(value) {
+  return value === "Error";
+}
+function parseModule(absolutePath, source) {
+  const result = parseSync(absolutePath, source, {
+    sourceType: "module",
+    showSemanticErrors: true
+  });
+  const error = result.errors.find((entry) => isParserErrorSeverity(entry.severity));
+  if (error !== void 0) {
+    throw new SyntaxError(
+      `SpotPatch could not safely parse ${path.basename(absolutePath)} (${error.message}).`
+    );
+  }
+  return Object.freeze({ program: result.program, source });
+}
+function importsOf(program) {
+  return program.body.filter(
+    (statement) => statement.type === "ImportDeclaration"
+  );
+}
+function importInsertionOffset(program) {
+  const lastImport = importsOf(program).at(-1);
+  if (lastImport !== void 0) {
+    return lastImport.end;
+  }
+  const directives = program.body.filter(
+    (statement) => statement.type === "ExpressionStatement" && typeof statement.directive === "string"
+  );
+  return directives.at(-1)?.end ?? program.hashbang?.end ?? 0;
+}
+function insertStaticImport(magicString, program, statement) {
+  const offset = importInsertionOffset(program);
+  if (offset === 0) {
+    magicString.prepend(`${statement}
+`);
+    return;
+  }
+  magicString.appendRight(offset, `
+${statement}`);
+}
+function collectIdentifierNames(program) {
+  const names = /* @__PURE__ */ new Set();
+  new Visitor({
+    Identifier(node) {
+      names.add(node.name);
+    }
+  }).visit(program);
+  return names;
+}
+function choosePluginName(program) {
+  const names = collectIdentifierNames(program);
+  let suffix = 0;
+  let candidate = "spotPatch";
+  while (names.has(candidate)) {
+    suffix += 1;
+    candidate = `spotPatch${String(suffix)}`;
+  }
+  return candidate;
+}
+function importedPluginName(program) {
+  const adapterImports = importsOf(program).filter(
+    (statement) => statement.source.value === ADAPTER_PACKAGE_NAME
+  );
+  if (adapterImports.length > 1) {
+    throw new Error("SpotPatch init found duplicate @spotpatch/vite imports.");
+  }
+  const adapterImport = adapterImports[0];
+  if (adapterImport === void 0) {
+    return void 0;
+  }
+  const plugin = adapterImport.specifiers.find(
+    (specifier) => specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "spotPatch" && specifier.importKind !== "type"
+  );
+  if (plugin === void 0) {
+    throw new Error(
+      "SpotPatch init cannot safely merge the existing @spotpatch/vite import."
+    );
+  }
+  return plugin.local.name;
+}
+function unwrapExpression(expression) {
+  let current = expression;
+  while (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression") {
+    current = current.expression;
+  }
+  return current;
+}
+function findDefaultExport(program) {
+  const exports = program.body.filter(
+    (statement) => statement.type === "ExportDefaultDeclaration"
+  );
+  if (exports.length !== 1 || exports[0] === void 0) {
+    throw new Error(
+      "SpotPatch init requires exactly one ESM default export in vite.config."
+    );
+  }
+  return exports[0];
+}
+function findVariableInitializer(program, name) {
+  for (const statement of program.body) {
+    if (statement.type !== "VariableDeclaration") {
+      continue;
+    }
+    for (const declaration of statement.declarations) {
+      if (declaration.id.type === "Identifier" && declaration.id.name === name && declaration.init !== null) {
+        return declaration.init;
+      }
+    }
+  }
+  return void 0;
+}
+function resolveConfigExpression(program) {
+  const exported = findDefaultExport(program).declaration;
+  if (exported.type === "FunctionDeclaration" || exported.type === "ClassDeclaration" || exported.type === "TSInterfaceDeclaration") {
+    throw new Error(
+      "SpotPatch init requires vite.config to export a configuration expression."
+    );
+  }
+  const expression = unwrapExpression(exported);
+  const resolved = expression.type === "Identifier" ? findVariableInitializer(program, expression.name) : expression;
+  if (resolved === void 0) {
+    throw new Error("SpotPatch init could not resolve the vite.config export.");
+  }
+  return unwrapExpression(resolved);
+}
+function resolveConfigObject(program) {
+  const expression = resolveConfigExpression(program);
+  if (expression.type === "ObjectExpression") {
+    return expression;
+  }
+  if (expression.type === "CallExpression") {
+    const callee = unwrapExpression(expression.callee);
+    const argument = expression.arguments[0];
+    if (callee.type === "Identifier" && callee.name === "defineConfig" && expression.arguments.length === 1 && argument !== void 0 && argument.type !== "SpreadElement") {
+      const value = unwrapExpression(argument);
+      if (value.type === "ObjectExpression") {
+        return value;
+      }
+    }
+  }
+  throw new Error(
+    "SpotPatch init currently supports an object passed to defineConfig in vite.config."
+  );
+}
+function propertyName(property) {
+  if (property.computed) {
+    return void 0;
+  }
+  if (property.key.type === "Identifier") {
+    return property.key.name;
+  }
+  if (property.key.type === "Literal" && typeof property.key.value === "string") {
+    return property.key.value;
+  }
+  return void 0;
+}
+function findProperty(object, name) {
+  const matches = object.properties.filter(
+    (property) => property.type === "Property" && propertyName(property) === name
+  );
+  if (matches.length > 1) {
+    throw new Error(`SpotPatch init found duplicate ${name} properties.`);
+  }
+  return matches[0];
+}
+function lineIndentAt(source, offset) {
+  const lineStart = source.lastIndexOf("\n", Math.max(0, offset - 1)) + 1;
+  return /^[\t ]*/u.exec(source.slice(lineStart, offset))?.[0] ?? "";
+}
+function childIndent(source, object) {
+  const first = object.properties[0];
+  if (first !== void 0) {
+    return lineIndentAt(source, first.start);
+  }
+  return `${lineIndentAt(source, object.start)}  `;
+}
+function trustedFastCall(pluginName, enabled) {
+  return enabled ? `${pluginName}({ trustedFastMode: true })` : `${pluginName}()`;
+}
+function directPluginCalls(plugins, pluginName) {
+  return plugins.elements.filter((element) => {
+    if (element?.type !== "CallExpression") {
+      return false;
+    }
+    const callee = unwrapExpression(element.callee);
+    return callee.type === "Identifier" && callee.name === pluginName;
+  });
+}
+function enableTrustedFastMode(magicString, source, call) {
+  if (call.arguments.length === 0) {
+    magicString.overwrite(
+      call.start,
+      call.end,
+      `${source.slice(call.start, call.end - 1)}{ trustedFastMode: true })`
+    );
+    return;
+  }
+  const argument = call.arguments[0];
+  if (call.arguments.length !== 1 || argument === void 0 || argument.type === "SpreadElement") {
+    throw new Error("SpotPatch init cannot safely update the spotPatch options.");
+  }
+  const value = unwrapExpression(argument);
+  if (value.type !== "ObjectExpression") {
+    throw new Error("SpotPatch init requires spotPatch options to be an object.");
+  }
+  const property = findProperty(value, "trustedFastMode");
+  if (property !== void 0) {
+    const propertyValue = unwrapExpression(property.value);
+    if (propertyValue.type !== "Literal" || typeof propertyValue.value !== "boolean") {
+      throw new Error(
+        "SpotPatch init requires trustedFastMode to be a boolean literal."
+      );
+    }
+    if (!propertyValue.value) {
+      magicString.overwrite(propertyValue.start, propertyValue.end, "true");
+    }
+    return;
+  }
+  const indent = childIndent(source, value);
+  if (value.properties.length === 0) {
+    magicString.appendLeft(value.end - 1, " trustedFastMode: true ");
+  } else {
+    magicString.appendLeft(
+      value.properties[0]?.start ?? value.end - 1,
+      `trustedFastMode: true,
+${indent}`
+    );
+  }
+}
+function addPluginCall(magicString, source, config, pluginName, trustedFastModeAvailable) {
+  const pluginsProperty = findProperty(config, "plugins");
+  const call = trustedFastCall(pluginName, trustedFastModeAvailable);
+  if (pluginsProperty === void 0) {
+    const indent = childIndent(source, config);
+    if (config.properties.length === 0) {
+      magicString.appendLeft(config.end - 1, `
+${indent}plugins: [${call}],
+`);
+    } else {
+      magicString.appendLeft(
+        config.properties[0]?.start ?? config.end - 1,
+        `plugins: [${call}],
+${indent}`
+      );
+    }
+    return;
+  }
+  const value = unwrapExpression(pluginsProperty.value);
+  if (value.type !== "ArrayExpression") {
+    throw new Error("SpotPatch init requires vite.config plugins to be an array.");
+  }
+  const existing = directPluginCalls(value, pluginName);
+  if (existing.length > 1) {
+    throw new Error("SpotPatch init found duplicate spotPatch plugins.");
+  }
+  if (existing[0] !== void 0) {
+    if (trustedFastModeAvailable) {
+      enableTrustedFastMode(magicString, source, existing[0]);
+    }
+    return;
+  }
+  const first = value.elements.find((element) => element !== null);
+  if (first === void 0) {
+    magicString.appendLeft(value.end - 1, call);
+  } else {
+    magicString.appendLeft(
+      first.start,
+      `${call},
+${lineIndentAt(source, first.start)}`
+    );
+  }
+}
+function transformViteConfig(absolutePath, source, trustedFastModeAvailable) {
+  const { program } = parseModule(absolutePath, source);
+  const config = resolveConfigObject(program);
+  const existingPluginName = importedPluginName(program);
+  const pluginName = existingPluginName ?? choosePluginName(program);
+  const magicString = new MagicString(source);
+  if (existingPluginName === void 0) {
+    const specifier = pluginName === "spotPatch" ? "spotPatch" : `spotPatch as ${pluginName}`;
+    insertStaticImport(
+      magicString,
+      program,
+      `import { ${specifier} } from ${JSON.stringify(ADAPTER_PACKAGE_NAME)};`
+    );
+  }
+  addPluginCall(magicString, source, config, pluginName, trustedFastModeAvailable);
+  return magicString.toString();
+}
+async function findViteConfig(appRoot) {
+  const candidates = (await Promise.all(
+    CONFIG_FILE_NAMES.map(async (name) => {
+      const absolutePath = path.join(appRoot, name);
+      return await integrationPathExists(absolutePath) ? absolutePath : void 0;
+    })
+  )).filter((value) => value !== void 0);
+  if (candidates.length !== 1 || candidates[0] === void 0) {
+    throw new Error("SpotPatch init requires exactly one supported vite.config file.");
+  }
+  return candidates[0];
+}
+async function planViteIntegration(directory = process.cwd()) {
+  const appRoot = path.resolve(directory);
+  const configPath = await findViteConfig(appRoot);
+  const [configSource, discoveredCheck] = await Promise.all([
+    readIntegrationFile(configPath),
+    discoverProjectValidationCheck({
+      appRoot,
+      timeoutMs: DEFAULT_AGENT_LIMITS.checkTimeoutMs
+    })
+  ]);
+  const trustedFastModeAvailable = discoveredCheck !== void 0;
+  const nextContent = transformViteConfig(
+    configPath,
+    configSource,
+    trustedFastModeAvailable
+  );
+  const change = createIntegrationFileChange(
+    appRoot,
+    configPath,
+    nextContent,
+    configSource
+  );
+  return Object.freeze({
+    appRoot,
+    changes: Object.freeze(change === void 0 ? [] : [change]),
+    trustedFastModeAvailable
+  });
+}
+async function applyViteIntegrationPlan(plan) {
+  await applyIntegrationPlan(plan);
+}
+async function checkViteIntegration(directory = process.cwd()) {
+  try {
+    const plan = await planViteIntegration(directory);
+    const issues = plan.changes.map(
+      (change) => `INTEGRATION_REQUIRED:${change.relativePath}`
+    );
+    return Object.freeze({
+      appRoot: plan.appRoot,
+      issues: Object.freeze(issues),
+      ok: issues.length === 0,
+      trustedFastModeAvailable: plan.trustedFastModeAvailable
+    });
+  } catch (error) {
+    return Object.freeze({
+      appRoot: path.resolve(directory),
+      issues: Object.freeze([
+        error instanceof Error ? error.message : "SpotPatch integration check failed."
+      ]),
+      ok: false,
+      trustedFastModeAvailable: false
+    });
+  }
+}
+
+// src/cli.ts
+var VERSION_PATTERN = /^(\d+)\.(\d+)\.(\d+)(?:-[0-9A-Za-z.-]+)?$/u;
+function writeUsage() {
+  process.stderr.write(
+    "Usage: spotpatch-vite <init|check>\n  init   Preview and apply safe Vite integration changes.\n  check  Verify the Vite integration without writing files.\n"
+  );
+}
+async function inspectViteProject(appRoot = process.cwd()) {
+  const resolveFromApplication = createRequire(path2.join(appRoot, "package.json"));
+  let adapterEntry;
+  let viteManifestPath;
+  try {
+    adapterEntry = resolveFromApplication.resolve("@spotpatch/vite");
+    viteManifestPath = resolveFromApplication.resolve("vite/package.json");
+  } catch (error) {
+    throw new Error(
+      "SpotPatch could not resolve the local @spotpatch/vite and Vite packages.",
+      { cause: error }
+    );
+  }
+  if (adapterEntry.length === 0) {
+    throw new Error("SpotPatch could not resolve the Vite adapter export.");
+  }
+  const manifest = JSON.parse(await readFile(viteManifestPath, "utf8"));
+  const version = typeof manifest === "object" && manifest !== null && "version" in manifest && typeof manifest.version === "string" ? manifest.version : void 0;
+  const match = version === void 0 ? null : VERSION_PATTERN.exec(version);
+  const major = Number(match?.[1]);
+  if (version === void 0 || match === null || !Number.isSafeInteger(major) || major < 5 || major >= 8) {
+    throw new Error(
+      `SpotPatch Vite requires Vite >=5.0.0 <8.0.0; found ${version ?? "unknown"}.`
+    );
+  }
+  return version;
+}
+function writeTrustedModeStatus(available) {
+  process.stdout.write(
+    available ? "[spotpatch:vite] trusted fast mode is available in the page selector.\n" : "[spotpatch:vite] review mode is ready; trusted fast mode needs a local TypeScript project check.\n"
+  );
+}
+async function runInit(arguments_) {
+  if (arguments_.length !== 0) {
+    throw new Error("SpotPatch init does not accept positional arguments.");
+  }
+  await inspectViteProject();
+  const plan = await planViteIntegration();
+  if (plan.changes.length === 0) {
+    process.stdout.write("[spotpatch:vite] integration is already up to date.\n");
+    writeTrustedModeStatus(plan.trustedFastModeAvailable);
+    return 0;
+  }
+  process.stdout.write("[spotpatch:vite] integration preview (resulting files):\n");
+  for (const change of plan.changes) {
+    process.stdout.write(`
+--- ${change.relativePath}
+${change.nextContent}`);
+    if (!change.nextContent.endsWith("\n")) {
+      process.stdout.write("\n");
+    }
+  }
+  await applyViteIntegrationPlan(plan);
+  process.stdout.write(
+    `[spotpatch:vite] updated ${String(plan.changes.length)} integration file(s).
+`
+  );
+  writeTrustedModeStatus(plan.trustedFastModeAvailable);
+  return 0;
+}
+async function runCheck(arguments_) {
+  if (arguments_.length !== 0) {
+    throw new Error("SpotPatch check does not accept positional arguments.");
+  }
+  const version = await inspectViteProject();
+  const result = await checkViteIntegration();
+  if (!result.ok) {
+    for (const issue of result.issues) {
+      process.stderr.write(`[spotpatch:vite] ${issue}
+`);
+    }
+    return 1;
+  }
+  const mode = result.trustedFastModeAvailable ? "trusted fast mode available" : "review mode";
+  process.stdout.write(
+    `[spotpatch:vite] integration verified for Vite ${version} \xB7 ${mode}.
+`
+  );
+  return 0;
+}
+async function main(arguments_) {
+  const [command, ...rest] = arguments_;
+  if (command === "init") {
+    return runInit(rest);
+  }
+  if (command === "check") {
+    return runCheck(rest);
+  }
+  writeUsage();
+  return 1;
+}
+try {
+  process.exitCode = await main(process.argv.slice(2));
+} catch (error) {
+  process.stderr.write(
+    `[spotpatch:vite] ${error instanceof Error ? error.message : "The command failed."}
+`
+  );
+  process.exitCode = 1;
+}
+//# sourceMappingURL=cli.js.map