vite-plus 0.2.7 → 0.2.9

package/binding/index.d.cts

@@ -2137,6 +2137,7 @@ export interface BindingDevtoolsOptions {
 }
 
 export interface BindingDevWatchOptions {
+  enabled?: boolean;
   skipWrite?: boolean;
   usePolling?: boolean;
   pollInterval?: number;
@@ -2332,7 +2333,9 @@ export interface BindingEsmExternalRequirePluginConfig {
 export interface BindingExperimentalDevModeOptions {
   host?: string;
   port?: number;
-  implement?: string;
+  implement: string;
+  /** @deprecated Common runtime injection will be disabled by default in the future. */
+  skipCommonRuntimeInjection?: boolean;
   lazy?: boolean;
 }
 
@@ -2388,6 +2391,23 @@ export interface BindingHookJsLoadOutput {
 
 export interface BindingHookJsResolveIdOptions {
   isEntry?: boolean;
+  /**
+   * - `import-statement`: `import { foo } from './lib.js';`
+   * - `dynamic-import`: `import('./lib.js')`
+   * - `require-call`: `require('./lib.js')`
+   * - `import-rule`: `@import 'bg-color.css'`
+   * - `url-token`: `url('./icon.png')`
+   * - `new-url`: `new URL('./worker.js', import.meta.url)`
+   * - `hot-accept`: `import.meta.hot.accept('./lib.js', () => {})`
+   */
+  kind?:
+    | 'import-statement'
+    | 'dynamic-import'
+    | 'require-call'
+    | 'import-rule'
+    | 'url-token'
+    | 'new-url'
+    | 'hot-accept';
   scan?: boolean;
   custom?: BindingVitePluginCustom;
 }
@@ -2414,6 +2434,24 @@ export interface BindingHookRenderChunkOutput {
   map?: BindingSourcemap | null;
 }
 
+export interface BindingHookResolveFileUrlArgs {
+  /** Preliminary filename of the chunk containing the reference. */
+  chunkId: string;
+  /** Filename of the emitted file, relative to the output directory. */
+  fileName: string;
+  format: 'es' | 'cjs' | 'iife' | 'umd';
+  /** Id of the module containing the `import.meta.ROLLDOWN_FILE_URL_*` reference. */
+  moduleId: string;
+  referenceId: string;
+  /** Path from the chunk to the emitted file. */
+  relativePath: string;
+  /**
+   * The `<urlId>` of `import.meta.ROLLDOWN_FILE_URL_<referenceId>_<urlId>`, if present.
+   * Only the rolldown-specific form carries it; the `ROLLUP_FILE_URL_` alias never does.
+   */
+  urlId?: string;
+}
+
 export interface BindingHookResolveIdExtraArgs {
   custom?: number;
   isEntry: boolean;
@@ -2461,6 +2499,14 @@ export interface BindingHookTransformOutput {
   moduleType?: string;
 }
 
+export interface BindingHotUpdateArgs {
+  kind: 'create' | 'update' | 'delete';
+  /** Normalized absolute path of the changed file. */
+  file: string;
+  /** The affected module ids as currently computed (raw module ids). */
+  modules: Array<string>;
+}
+
 export interface BindingIndentOptions {
   exclude?: Array<Array<number>> | Array<number>;
 }
@@ -2514,6 +2560,8 @@ export interface BindingInputOptions {
   keepNames?: boolean;
   checks?: BindingChecksOptions;
   deferSyncScanData?: undefined | (() => BindingDeferSyncScanData[]);
+  /** Asked for while the build is closing, so what it returns includes `closeBundle`. */
+  pluginTimings?: undefined | (() => BindingPluginTimingsMeasurement);
   makeAbsoluteExternalsRelative?: BindingMakeAbsoluteExternalsRelative;
   devtools?: BindingDevtoolsOptions;
   invalidateJsSideCache?: () => void;
@@ -2549,6 +2597,13 @@ export interface BindingJsWatchChangeEvent {
 export interface BindingLazyChunkOutput {
   code: string;
   filename: string;
+  /**
+   * The chunk's sourcemap, when `sourcemap` is `File` or `Hidden`. Serve it
+   * under `sourcemapFilename`, which is what the chunk's `sourceMappingURL`
+   * refers to.
+   */
+  sourcemap?: string;
+  sourcemapFilename?: string;
 }
 
 export interface BindingLog {
@@ -2691,6 +2746,8 @@ export interface BindingOutputs {
 
 export interface BindingOverwriteOptions {
   contentOnly?: boolean;
+  /** Stores the replaced content in the generated sourcemap's `names` field. */
+  storeName?: boolean;
 }
 
 export interface BindingPluginContextResolvedId {
@@ -2785,6 +2842,11 @@ export interface BindingPluginOptions {
     chunk: BindingRenderedChunk,
   ) => MaybePromise<void | string>;
   augmentChunkHashMeta?: BindingPluginHookMeta;
+  resolveFileUrl?: (
+    ctx: BindingPluginContext,
+    args: BindingHookResolveFileUrlArgs,
+  ) => MaybePromise<void | string | null>;
+  resolveFileUrlMeta?: BindingPluginHookMeta;
   renderStart?: (ctx: BindingPluginContext, opts: BindingNormalizedOptions) => void;
   renderStartMeta?: BindingPluginHookMeta;
   renderError?: (ctx: BindingPluginContext, error: BindingError[]) => void;
@@ -2810,6 +2872,11 @@ export interface BindingPluginOptions {
     event: string,
   ) => MaybePromise<VoidNullable>;
   watchChangeMeta?: BindingPluginHookMeta;
+  hotUpdate?: (
+    ctx: BindingPluginContext,
+    args: BindingHotUpdateArgs,
+  ) => MaybePromise<VoidNullable<Array<string>>>;
+  hotUpdateMeta?: BindingPluginHookMeta;
   closeWatcher?: (ctx: BindingPluginContext) => MaybePromise<VoidNullable>;
   closeWatcherMeta?: BindingPluginHookMeta;
   banner?: (ctx: BindingPluginContext, chunk: BindingRenderedChunk) => void;
@@ -2827,6 +2894,33 @@ export declare const enum BindingPluginOrder {
   Post = 1,
 }
 
+/**
+ * What one callback cost, measured inside it on the JavaScript side — the one place the
+ * measurement exists, since this side can only bracket dispatch and completion.
+ */
+export interface BindingPluginTiming {
+  /** The plugin the callback belongs to, or the options it was configured on. */
+  owner: string;
+  kind: 'plugin' | 'outputOption' | 'inputOption';
+  hook: string;
+  calls: number;
+  ms: number;
+  maxInFlight: number;
+  /** How much of `ms` is double counted because calls overlapped. */
+  overlapMs: number;
+  /**
+   * Whether `ms` may be compared against another row's — false once two calls of this hook
+   * overlapped, because then their spans cover work each other was doing.
+   */
+  rankable: boolean;
+}
+
+export interface BindingPluginTimingsMeasurement {
+  /** Wall time in which any measured callback was running, counting overlap once. */
+  busyMs: number;
+  rows: Array<BindingPluginTiming>;
+}
+
 export interface BindingPluginWithIndex {
   index: number;
   plugin: BindingPluginOptions;
@@ -2982,6 +3076,8 @@ export interface BindingTsconfigResult {
 
 export interface BindingUpdateOptions {
   overwrite?: boolean;
+  /** Stores the replaced content in the generated sourcemap's `names` field. */
+  storeName?: boolean;
 }
 
 export interface BindingViteAliasPluginAlias {
@@ -3241,19 +3337,14 @@ export declare function resolveTsconfig(
 ): BindingTsconfigResult | null;
 
 /**
- * Shutdown the tokio runtime manually.
+ * Release one holder of the tokio runtime, shutting it down once none are left.
  *
  * This is required for the wasm target with `tokio_unstable` cfg.
  * In the wasm runtime, the `park` threads will hang there until the tokio::Runtime is shutdown.
  */
 export declare function shutdownAsyncRuntime(): void;
 
-/**
- * Start the async runtime manually.
- *
- * This is required when the async runtime is shutdown manually.
- * Usually it's used in test.
- */
+/** Acquire one holder of the tokio runtime, starting it if it is not running. */
 export declare function startAsyncRuntime(): void;
 
 export interface ViteImportGlobMeta {
@@ -3288,6 +3379,10 @@ export interface CliOptions {
   cwd?: string;
   /** CLI arguments (should be process.argv.slice(2) from JavaScript) */
   args?: Array<string>;
+  /** Generated toolchain manifest shipped with this vite-plus package. */
+  toolchainManifestPath: string;
+  /** Root directory of this vite-plus package. */
+  vitePlusPackagePath: string;
   /** Read the vite.config.ts in the Node.js side and return the `lint` and `fmt` config JSON string back to the Rust side */
   resolveUniversalViteConfig: (err: Error | null, arg: string) => Promise<string>;
 }
@@ -3573,7 +3668,7 @@ export declare function rewriteScripts(scriptsJson: string, rulesYaml: string):
  * Main entry point for the CLI, called from JavaScript.
  *
  * This is an async function that spawns a new thread for the non-Send async code
- * from vite_task, while allowing the NAPI async context to continue running
+ * from vt, while allowing the NAPI async context to continue running
  * and process JavaScript callbacks (via ThreadsafeFunction).
  */
 export declare function run(options: CliOptions): Promise<number>;
@@ -3581,7 +3676,7 @@ export declare function run(options: CliOptions): Promise<number>;
 /**
  * Run a command with fspy tracking, callable from JavaScript.
  *
- * This function wraps `vite_command::run_command_with_fspy` to provide
+ * This function wraps `vp_command::run_command_with_fspy` to provide
  * a JavaScript-friendly interface for executing commands and tracking
  * their file system accesses.
  *
@@ -3651,7 +3746,7 @@ export interface RunCommandResult {
 /**
  * Whether the Vite+ banner should be emitted in the current environment.
  *
- * Mirrors `vite_shared::header::should_print_header` so both CLIs apply
+ * Mirrors `vp_shared::header::should_print_header` so both CLIs apply
  * the same TTY + git-hook gating without duplicating the rules in JS.
  */
 export declare function shouldPrintVitePlusHeader(): boolean;

package/dist/agent-DQU8uS6P.js

@@ -0,0 +1,416 @@
+import { A as isCancel, C as log, E as select, w as multiselect } from "./prompts-CHz_98bJ.js";
+import path from "node:path";
+import { styleText } from "node:util";
+import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+//#region src/utils/path.ts
+function findPkgRoot() {
+	let dir = import.meta.dirname;
+	while (dir !== path.dirname(dir)) {
+		if (fs.existsSync(path.join(dir, "package.json"))) return dir;
+		dir = path.dirname(dir);
+	}
+	return dir;
+}
+const pkgRoot = findPkgRoot();
+const templatesDir = path.join(pkgRoot, "templates");
+const rulesDir = path.join(pkgRoot, "rules");
+function displayRelative(to, from = process.cwd()) {
+	return path.relative(from, to).replaceAll("\\", "/");
+}
+//#endregion
+//#region src/utils/agent.ts
+const AGENTS = [
+	{
+		id: "agents",
+		label: "AGENTS.md",
+		targetPath: "AGENTS.md",
+		hint: "Codex, Amp, OpenCode, and similar agents",
+		aliases: [
+			"agents.md",
+			"chatgpt",
+			"chatgpt-codex",
+			"codex",
+			"amp",
+			"kilo",
+			"kilo-code",
+			"kiro",
+			"kiro-cli",
+			"opencode",
+			"other"
+		]
+	},
+	{
+		id: "claude",
+		label: "CLAUDE.md",
+		targetPath: "CLAUDE.md",
+		hint: "Claude Code",
+		aliases: ["claude.md", "claude-code"]
+	},
+	{
+		id: "gemini",
+		label: "GEMINI.md",
+		targetPath: "GEMINI.md",
+		hint: "Gemini CLI",
+		aliases: ["gemini.md", "gemini-cli"]
+	},
+	{
+		id: "copilot",
+		label: ".github/copilot-instructions.md",
+		targetPath: ".github/copilot-instructions.md",
+		hint: "GitHub Copilot",
+		aliases: ["github-copilot", "copilot-instructions.md"]
+	},
+	{
+		id: "cursor",
+		label: ".cursor/rules/viteplus.mdc",
+		targetPath: ".cursor/rules/viteplus.mdc",
+		hint: "Cursor",
+		aliases: ["viteplus.mdc"]
+	},
+	{
+		id: "jetbrains",
+		label: ".aiassistant/rules/viteplus.md",
+		targetPath: ".aiassistant/rules/viteplus.md",
+		hint: "JetBrains AI Assistant",
+		aliases: [
+			"jetbrains",
+			"jetbrains-ai-assistant",
+			"aiassistant",
+			"viteplus.md"
+		]
+	}
+];
+const AGENT_DEFAULT_ID = "agents";
+const AGENT_STANDARD_PATH = "AGENTS.md";
+const COPILOT_AGENT_ID = "copilot";
+const COPILOT_SETUP_WORKFLOW_PATH = ".github/workflows/copilot-setup-steps.yml";
+const AGENT_INSTRUCTIONS_START_MARKER = "<!--VITE PLUS START-->";
+const AGENT_INSTRUCTIONS_END_MARKER = "<!--VITE PLUS END-->";
+const AGENT_ALIASES = Object.fromEntries(AGENTS.flatMap((option) => (option.aliases ?? []).map((alias) => [normalizeAgentName(alias), option.id])));
+const COPILOT_SETUP_WORKFLOW_CONTENT = `name: "Copilot Setup Steps"
+
+on:
+  workflow_dispatch:
+  push:
+    paths:
+      - .github/workflows/copilot-setup-steps.yml
+  pull_request:
+    paths:
+      - .github/workflows/copilot-setup-steps.yml
+
+jobs:
+  copilot-setup-steps:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+      - name: Set up Vite+
+        uses: voidzero-dev/setup-vp@v1
+        with:
+          cache: true
+          run-install: true
+      - name: Verify Vite+
+        run: vp --version
+`;
+async function selectAgentTargets({ interactive, agent, onCancel }) {
+	if (agent === false) return {
+		targetPaths: void 0,
+		selectedAgents: []
+	};
+	if (interactive && !agent) {
+		const selectedAgentIds = await multiselect({
+			message: "Which coding agent instruction files should Vite+ create?",
+			options: AGENTS.map((option) => ({
+				label: option.label,
+				value: option.id,
+				hint: option.hint
+			})),
+			initialValues: [AGENT_DEFAULT_ID],
+			required: false
+		});
+		if (isCancel(selectedAgentIds)) {
+			onCancel();
+			return {
+				targetPaths: void 0,
+				selectedAgents: []
+			};
+		}
+		if (selectedAgentIds.length === 0) return {
+			targetPaths: void 0,
+			selectedAgents: []
+		};
+		const selectedAgents = resolveAgentOptions(selectedAgentIds);
+		return {
+			targetPaths: getAgentTargetPaths(selectedAgents),
+			selectedAgents
+		};
+	}
+	const selectedAgents = resolveAgentOptions(agent ?? AGENT_DEFAULT_ID);
+	return {
+		targetPaths: getAgentTargetPaths(selectedAgents),
+		selectedAgents
+	};
+}
+async function selectAgentTargetPaths({ interactive, agent, onCancel }) {
+	return (await selectAgentTargets({
+		interactive,
+		agent,
+		onCancel
+	})).targetPaths;
+}
+function detectExistingAgentTargetPaths(projectRoot) {
+	const detectedPaths = [];
+	const seenTargetPaths = /* @__PURE__ */ new Set();
+	for (const option of AGENTS) {
+		if (seenTargetPaths.has(option.targetPath)) continue;
+		seenTargetPaths.add(option.targetPath);
+		const targetPath = path.join(projectRoot, option.targetPath);
+		if (fs.existsSync(targetPath) && !fs.lstatSync(targetPath).isSymbolicLink()) detectedPaths.push(option.targetPath);
+	}
+	return detectedPaths.length > 0 ? detectedPaths : void 0;
+}
+/**
+* Silently update agent instruction files that contain Vite+ markers.
+* - No agent files → no writes
+* - No Vite+ markers → no writes
+* - Markers present, content up to date → no writes
+* - Markers present, content outdated → update marked section
+*/
+function updateExistingAgentInstructions(projectRoot) {
+	const targetPaths = detectExistingAgentTargetPaths(projectRoot);
+	if (!targetPaths) return;
+	const templatePath = path.join(pkgRoot, "AGENTS.md");
+	if (!fs.existsSync(templatePath)) return;
+	const templateContent = fs.readFileSync(templatePath, "utf-8");
+	for (const targetPath of targetPaths) try {
+		const fullPath = path.join(projectRoot, targetPath);
+		const existing = fs.readFileSync(fullPath, "utf-8");
+		const updated = replaceMarkedAgentInstructionsSection(existing, templateContent);
+		if (updated !== void 0 && updated !== existing) fs.writeFileSync(fullPath, updated);
+	} catch {}
+}
+function resolveAgentOptions(agent) {
+	const agentNames = parseAgentNames(agent);
+	const resolvedAgentNames = agentNames.length > 0 ? agentNames : [AGENT_DEFAULT_ID];
+	const dedupedAgents = [];
+	const seenAgentIds = /* @__PURE__ */ new Set();
+	for (const name of resolvedAgentNames) {
+		const option = resolveSingleAgentOption(name);
+		if (seenAgentIds.has(option.id)) continue;
+		seenAgentIds.add(option.id);
+		dedupedAgents.push(option);
+	}
+	return dedupedAgents;
+}
+function getAgentTargetPaths(agents) {
+	const dedupedTargetPaths = [];
+	const seenTargetPaths = /* @__PURE__ */ new Set();
+	for (const agent of agents) {
+		if (seenTargetPaths.has(agent.targetPath)) continue;
+		seenTargetPaths.add(agent.targetPath);
+		dedupedTargetPaths.push(agent.targetPath);
+	}
+	return dedupedTargetPaths;
+}
+function parseAgentNames(agent) {
+	if (!agent) return [];
+	return (Array.isArray(agent) ? agent : [agent]).filter((value) => typeof value === "string").flatMap((value) => value.split(",")).map((value) => value.trim()).filter((value) => value.length > 0);
+}
+function resolveSingleAgentOption(agent) {
+	const normalized = normalizeAgentName(agent);
+	const alias = AGENT_ALIASES[normalized];
+	const resolved = alias ? normalizeAgentName(alias) : normalized;
+	return AGENTS.find((option) => normalizeAgentName(option.id) === resolved || normalizeAgentName(option.label) === resolved || normalizeAgentName(option.targetPath) === resolved || option.aliases?.some((candidate) => normalizeAgentName(candidate) === resolved)) ?? AGENTS.find((option) => option.id === AGENT_DEFAULT_ID);
+}
+/** Order target paths for the shared detect/write traversal: AGENTS.md first. */
+function orderAgentTargetPaths(projectRoot, targetPaths) {
+	const orderedPaths = targetPaths.includes(AGENT_STANDARD_PATH) ? [AGENT_STANDARD_PATH, ...targetPaths.filter((p) => p !== AGENT_STANDARD_PATH)] : targetPaths;
+	const dedupedPaths = [];
+	const seenDestinationPaths = /* @__PURE__ */ new Set();
+	for (const targetPath of orderedPaths) {
+		const destinationKey = path.resolve(path.join(projectRoot, targetPath));
+		if (seenDestinationPaths.has(destinationKey)) continue;
+		seenDestinationPaths.add(destinationKey);
+		dedupedPaths.push(targetPath);
+	}
+	return dedupedPaths;
+}
+/**
+* Classify an existing agent instruction file for the shared detect/write
+* traversal. Registers the file's realpath in the caller-owned `seenRealPaths`.
+*/
+async function classifyExistingAgentTarget(destinationPath, incomingContent, seenRealPaths) {
+	if (fs.lstatSync(destinationPath).isSymbolicLink()) return { kind: "symlink" };
+	const destinationRealPath = await fsPromises.realpath(destinationPath);
+	if (seenRealPaths.has(destinationRealPath)) return { kind: "duplicate" };
+	seenRealPaths.add(destinationRealPath);
+	const existingContent = await fsPromises.readFile(destinationPath, "utf-8");
+	const updatedContent = replaceMarkedAgentInstructionsSection(existingContent, incomingContent);
+	if (updatedContent !== void 0) return {
+		kind: "markers",
+		existingContent,
+		updatedContent
+	};
+	return {
+		kind: "conflict",
+		existingContent
+	};
+}
+/**
+* Detect agent instruction files that would conflict (exist without markers).
+* Returns only files that need a user decision (append or skip).
+* Read-only — does not write or modify any files.
+*/
+async function detectAgentConflicts({ projectRoot, targetPaths }) {
+	if (!targetPaths || targetPaths.length === 0) return [];
+	const sourcePath = path.join(pkgRoot, "AGENTS.md");
+	if (!fs.existsSync(sourcePath)) return [];
+	const incomingContent = await fsPromises.readFile(sourcePath, "utf-8");
+	const shouldLinkToAgents = targetPaths.includes(AGENT_STANDARD_PATH);
+	const conflicts = [];
+	const seenRealPaths = /* @__PURE__ */ new Set();
+	for (const targetPathToCheck of orderAgentTargetPaths(projectRoot, targetPaths)) {
+		const destinationPath = path.join(projectRoot, targetPathToCheck);
+		if (shouldLinkToAgents && targetPathToCheck !== AGENT_STANDARD_PATH) {
+			if (await getExistingPathKind(destinationPath) !== "file") continue;
+		}
+		if (!fs.existsSync(destinationPath)) continue;
+		if ((await classifyExistingAgentTarget(destinationPath, incomingContent, seenRealPaths)).kind === "conflict") conflicts.push({ targetPath: targetPathToCheck });
+	}
+	return conflicts;
+}
+async function writeAgentInstructions({ projectRoot, targetPath, targetPaths, interactive, conflictDecisions, silent = false }) {
+	const paths = [...targetPaths ?? [], ...targetPath ? [targetPath] : []];
+	if (paths.length === 0) return;
+	const sourcePath = path.join(pkgRoot, "AGENTS.md");
+	if (!fs.existsSync(sourcePath)) {
+		if (!silent) log.warn("Agent instructions template not found; skipping.");
+		return;
+	}
+	const seenRealPaths = /* @__PURE__ */ new Set();
+	const incomingContent = await fsPromises.readFile(sourcePath, "utf-8");
+	const shouldLinkToAgents = paths.includes(AGENT_STANDARD_PATH);
+	for (const targetPathToWrite of orderAgentTargetPaths(projectRoot, paths)) {
+		const destinationPath = path.join(projectRoot, targetPathToWrite);
+		await fsPromises.mkdir(path.dirname(destinationPath), { recursive: true });
+		if (shouldLinkToAgents && targetPathToWrite !== AGENT_STANDARD_PATH) {
+			if (await tryLinkTargetToAgents(projectRoot, targetPathToWrite, silent)) continue;
+		}
+		if (fs.existsSync(destinationPath)) {
+			const state = await classifyExistingAgentTarget(destinationPath, incomingContent, seenRealPaths);
+			if (state.kind === "symlink") {
+				if (!silent) log.info(`Skipped writing ${targetPathToWrite} (symlink)`);
+				continue;
+			}
+			if (state.kind === "duplicate") {
+				if (!silent) log.info(`Skipped writing ${targetPathToWrite} (duplicate target)`);
+				continue;
+			}
+			if (state.kind === "markers") {
+				if (state.updatedContent !== state.existingContent) await fsPromises.writeFile(destinationPath, state.updatedContent);
+				continue;
+			}
+			let conflictAction;
+			const preResolved = conflictDecisions?.get(targetPathToWrite);
+			if (preResolved) conflictAction = preResolved;
+			else if (interactive) {
+				const action = await select({
+					message: `Agent instructions already exist at ${targetPathToWrite}.\n  ` + styleText("gray", "The Vite+ template includes guidance on `vp` commands, the build pipeline, and project conventions."),
+					options: [{
+						label: "Append",
+						value: "append",
+						hint: "Add template content to the end"
+					}, {
+						label: "Skip",
+						value: "skip",
+						hint: "Leave existing file unchanged"
+					}],
+					initialValue: "skip"
+				});
+				conflictAction = isCancel(action) || action === "skip" ? "skip" : "append";
+			} else conflictAction = "skip";
+			if (conflictAction === "append") await appendAgentContent(destinationPath, targetPathToWrite, state.existingContent, incomingContent, silent);
+			else {
+				const suffix = !preResolved && !interactive ? " (already exists)" : "";
+				if (!silent) log.info(`Skipped writing ${targetPathToWrite}${suffix}`);
+			}
+			continue;
+		}
+		await fsPromises.writeFile(destinationPath, incomingContent);
+		if (!silent) log.success(`Wrote agent instructions to ${targetPathToWrite}`);
+		seenRealPaths.add(await fsPromises.realpath(destinationPath));
+	}
+}
+async function writeCopilotSetupWorkflow({ projectRoot, silent = false }) {
+	const destinationPath = path.join(projectRoot, COPILOT_SETUP_WORKFLOW_PATH);
+	await fsPromises.mkdir(path.dirname(destinationPath), { recursive: true });
+	if (fs.existsSync(destinationPath)) {
+		if (!silent) log.info(`Skipped writing ${COPILOT_SETUP_WORKFLOW_PATH} (already exists)`);
+		return;
+	}
+	await fsPromises.writeFile(destinationPath, COPILOT_SETUP_WORKFLOW_CONTENT);
+	if (!silent) log.success(`Wrote Copilot setup workflow to ${COPILOT_SETUP_WORKFLOW_PATH}`);
+}
+async function appendAgentContent(destinationPath, targetPath, existingContent, incomingContent, silent = false) {
+	const separator = existingContent.endsWith("\n") ? "" : "\n";
+	await fsPromises.appendFile(destinationPath, `${separator}\n${incomingContent}`);
+	if (!silent) log.success(`Appended agent instructions to ${targetPath}`);
+}
+function normalizeAgentName(value) {
+	return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function replaceMarkedAgentInstructionsSection(existing, incoming) {
+	const existingRange = getMarkedRange(existing, AGENT_INSTRUCTIONS_START_MARKER, AGENT_INSTRUCTIONS_END_MARKER);
+	if (!existingRange) return;
+	const incomingRange = getMarkedRange(incoming, AGENT_INSTRUCTIONS_START_MARKER, AGENT_INSTRUCTIONS_END_MARKER);
+	if (!incomingRange) return;
+	return `${existing.slice(0, existingRange.start)}${incoming.slice(incomingRange.start, incomingRange.end)}${existing.slice(existingRange.end)}`;
+}
+async function tryLinkTargetToAgents(projectRoot, targetPath, silent = false) {
+	const destinationPath = path.join(projectRoot, targetPath);
+	const agentsPath = path.join(projectRoot, AGENT_STANDARD_PATH);
+	const symlinkTarget = path.relative(path.dirname(destinationPath), agentsPath);
+	const existing = await getExistingPathKind(destinationPath);
+	if (existing === "file") return false;
+	if (existing === "symlink") {
+		const currentLink = await fsPromises.readlink(destinationPath);
+		if (path.resolve(path.dirname(destinationPath), currentLink) === agentsPath) {
+			if (!silent) log.info(`Skipped linking ${targetPath} (already linked to ${AGENT_STANDARD_PATH})`);
+			return true;
+		}
+		await fsPromises.unlink(destinationPath);
+	}
+	try {
+		await fsPromises.symlink(symlinkTarget, destinationPath);
+	} catch (err) {
+		if (err.code === "EPERM") {
+			await fsPromises.copyFile(agentsPath, destinationPath);
+			if (!silent) log.success(`Copied ${AGENT_STANDARD_PATH} to ${targetPath}`);
+			return true;
+		}
+		throw err;
+	}
+	if (!silent) log.success(`Linked ${targetPath} to ${AGENT_STANDARD_PATH}`);
+	return true;
+}
+async function getExistingPathKind(filePath) {
+	if (!fs.existsSync(filePath)) return "missing";
+	return (await fsPromises.lstat(filePath)).isSymbolicLink() ? "symlink" : "file";
+}
+function getMarkedRange(content, startMarker, endMarker) {
+	const start = content.indexOf(startMarker);
+	if (start === -1) return;
+	const endMarkerIndex = content.indexOf(endMarker, start + startMarker.length);
+	if (endMarkerIndex === -1) return;
+	return {
+		start,
+		end: endMarkerIndex + endMarker.length
+	};
+}
+//#endregion
+export { selectAgentTargets as a, writeCopilotSetupWorkflow as c, templatesDir as d, selectAgentTargetPaths as i, displayRelative as l, detectAgentConflicts as n, updateExistingAgentInstructions as o, detectExistingAgentTargetPaths as r, writeAgentInstructions as s, COPILOT_AGENT_ID as t, rulesDir as u };