t3code-cli 0.13.0 → 0.14.0

package/dist/shared/schemaYaml.d.ts

@@ -0,0 +1,86 @@
+import * as Schema from "effect/Schema";
+import * as SchemaGetter from "effect/SchemaGetter";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+import { CreateNodeOptions, DocumentOptions, ParseOptions, SchemaOptions, ToJSOptions, ToStringOptions } from "yaml";
+//#region upstream-t3code/packages/shared/src/schemaYaml.d.ts
+type YamlParseOptions = ParseOptions & DocumentOptions & SchemaOptions & ToJSOptions;
+type YamlStringifyOptions = DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions & ToStringOptions;
+/**
+ * Parses a YAML string into a value.
+ *
+ * **When to use**
+ *
+ * Use when you need a schema getter to parse a present encoded YAML string
+ * during decoding.
+ *
+ * **Details**
+ *
+ * Parse failures become `SchemaIssue.InvalidValue` values.
+ *
+ * **Example** (Parse YAML)
+ *
+ * ```ts
+ * import { parseYaml } from "@t3tools/shared/schemaYaml"
+ *
+ * const parse = parseYaml<string>()
+ * // Getter<unknown, string>
+ * ```
+ *
+ * @see {@link stringifyYaml} for the inverse operation
+ */
+declare function parseYaml<E extends string>(options?: YamlParseOptions): SchemaGetter.Getter<unknown, E>;
+/**
+ * Stringifies a present value as YAML.
+ *
+ * **When to use**
+ *
+ * Use when you need a schema getter to serialize a present decoded value to
+ * YAML text during encoding.
+ *
+ * **Details**
+ *
+ * Stringify failures become `SchemaIssue.InvalidValue` values.
+ *
+ * **Example** (Stringify YAML)
+ *
+ * ```ts
+ * import { stringifyYaml } from "@t3tools/shared/schemaYaml"
+ *
+ * const stringify = stringifyYaml()
+ * // Getter<string, unknown>
+ * ```
+ *
+ * @see {@link parseYaml} for the inverse operation
+ */
+declare function stringifyYaml(options?: YamlStringifyOptions): SchemaGetter.Getter<string, unknown>;
+/**
+ * Decodes a YAML string and encodes a value as YAML text.
+ *
+ * **When to use**
+ *
+ * Use when you need a schema transformation to decode YAML stored or
+ * transmitted as a string before validating the parsed structure.
+ *
+ * **Details**
+ *
+ * Decode and encode failures become `InvalidValue` schema issues.
+ *
+ * **Example** (Parsing YAML)
+ *
+ * ```ts
+ * import * as Schema from "effect/Schema"
+ * import { fromYamlString } from "@t3tools/shared/schemaYaml"
+ *
+ * const schema = Schema.String.pipe(Schema.decodeTo(Schema.Unknown, fromYamlString))
+ * ```
+ */
+declare const fromYamlString: SchemaTransformation.Transformation<unknown, string, never, never>;
+/**
+ * Build a schema that decodes a YAML string into `A`.
+ *
+ * Decode parses the input as YAML before validating the parsed value with the
+ * provided schema. Encode validates the value and serializes it as YAML text.
+ */
+declare const fromYaml: <S extends Schema.Top>(schema: S) => Schema.decodeTo<S, Schema.String, never, never>;
+//#endregion
+export { YamlParseOptions, YamlStringifyOptions, fromYaml, fromYamlString, parseYaml, stringifyYaml };

package/dist/shared/schemaYaml.js

@@ -0,0 +1,99 @@
+import { a as __toESM } from "../rolldown-runtime.js";
+import { DD as transformOrFail, ED as Transformation, PD as InvalidValue, PO as try_, QT as String, Uk as none, jT as require_dist, rE as decodeTo } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/schemaYaml.ts
+var import_dist = /* @__PURE__ */ __toESM(require_dist(), 1);
+function formatYamlParseError(error) {
+	if (!(error instanceof import_dist.YAMLParseError)) return "Invalid YAML.";
+	const position = error.linePos?.[0];
+	const location = position === void 0 ? "" : `, line=${position.line}, column=${position.col}`;
+	return `Invalid YAML (code=${error.code}${location}).`;
+}
+/**
+* Parses a YAML string into a value.
+*
+* **When to use**
+*
+* Use when you need a schema getter to parse a present encoded YAML string
+* during decoding.
+*
+* **Details**
+*
+* Parse failures become `SchemaIssue.InvalidValue` values.
+*
+* **Example** (Parse YAML)
+*
+* ```ts
+* import { parseYaml } from "@t3tools/shared/schemaYaml"
+*
+* const parse = parseYaml<string>()
+* // Getter<unknown, string>
+* ```
+*
+* @see {@link stringifyYaml} for the inverse operation
+*/
+function parseYaml(options) {
+	return transformOrFail((input) => try_({
+		try: () => (0, import_dist.parse)(input, options),
+		catch: (error) => new InvalidValue(none(), { message: formatYamlParseError(error) })
+	}));
+}
+/**
+* Stringifies a present value as YAML.
+*
+* **When to use**
+*
+* Use when you need a schema getter to serialize a present decoded value to
+* YAML text during encoding.
+*
+* **Details**
+*
+* Stringify failures become `SchemaIssue.InvalidValue` values.
+*
+* **Example** (Stringify YAML)
+*
+* ```ts
+* import { stringifyYaml } from "@t3tools/shared/schemaYaml"
+*
+* const stringify = stringifyYaml()
+* // Getter<string, unknown>
+* ```
+*
+* @see {@link parseYaml} for the inverse operation
+*/
+function stringifyYaml(options) {
+	return transformOrFail((input) => try_({
+		try: () => (0, import_dist.stringify)(input, options),
+		catch: () => new InvalidValue(none(), { message: "Failed to stringify YAML." })
+	}));
+}
+/**
+* Decodes a YAML string and encodes a value as YAML text.
+*
+* **When to use**
+*
+* Use when you need a schema transformation to decode YAML stored or
+* transmitted as a string before validating the parsed structure.
+*
+* **Details**
+*
+* Decode and encode failures become `InvalidValue` schema issues.
+*
+* **Example** (Parsing YAML)
+*
+* ```ts
+* import * as Schema from "effect/Schema"
+* import { fromYamlString } from "@t3tools/shared/schemaYaml"
+*
+* const schema = Schema.String.pipe(Schema.decodeTo(Schema.Unknown, fromYamlString))
+* ```
+*/
+const fromYamlString = new Transformation(parseYaml(), stringifyYaml());
+/**
+* Build a schema that decodes a YAML string into `A`.
+*
+* Decode parses the input as YAML before validating the parsed value with the
+* provided schema. Encode validates the value and serializes it as YAML text.
+*/
+const fromYaml = (schema) => String.pipe(decodeTo(schema, fromYamlString));
+//#endregion
+export { fromYaml, fromYamlString, parseYaml, stringifyYaml };

package/dist/shared/searchRanking.d.ts

@@ -0,0 +1,30 @@
+//#region upstream-t3code/packages/shared/src/searchRanking.d.ts
+type RankedSearchResult<T> = {
+  item: T;
+  score: number;
+  tieBreaker: string;
+};
+declare function normalizeSearchQuery(input: string, options?: {
+  trimLeadingPattern?: RegExp;
+}): string;
+declare function scoreSubsequenceMatch(value: string, query: string): number | null;
+/**
+ * Scores how well `value` matches `query` using tiered match strategies.
+ *
+ * **Expects pre-normalized inputs**: both `value` and `query` must already be
+ * trimmed and lowercased (e.g. via {@link normalizeSearchQuery}).
+ */
+declare function scoreQueryMatch(input: {
+  value: string;
+  query: string;
+  exactBase: number;
+  prefixBase?: number;
+  boundaryBase?: number;
+  includesBase?: number;
+  fuzzyBase?: number;
+  boundaryMarkers?: readonly string[];
+}): number | null;
+declare function compareRankedSearchResults<T>(left: RankedSearchResult<T>, right: RankedSearchResult<T>): number;
+declare function insertRankedSearchResult<T>(rankedEntries: RankedSearchResult<T>[], candidate: RankedSearchResult<T>, limit: number): void;
+//#endregion
+export { RankedSearchResult, compareRankedSearchResults, insertRankedSearchResult, normalizeSearchQuery, scoreQueryMatch, scoreSubsequenceMatch };

package/dist/shared/searchRanking.js

@@ -0,0 +1,99 @@
+//#region upstream-t3code/packages/shared/src/searchRanking.ts
+function normalizeSearchQuery(input, options) {
+	const trimmed = input.trim();
+	if (!trimmed) return "";
+	return options?.trimLeadingPattern ? trimmed.replace(options.trimLeadingPattern, "").toLowerCase() : trimmed.toLowerCase();
+}
+function scoreSubsequenceMatch(value, query) {
+	if (!query) return 0;
+	let queryIndex = 0;
+	let firstMatchIndex = -1;
+	let previousMatchIndex = -1;
+	let gapPenalty = 0;
+	for (let valueIndex = 0; valueIndex < value.length; valueIndex += 1) {
+		if (value[valueIndex] !== query[queryIndex]) continue;
+		if (firstMatchIndex === -1) firstMatchIndex = valueIndex;
+		if (previousMatchIndex !== -1) gapPenalty += valueIndex - previousMatchIndex - 1;
+		previousMatchIndex = valueIndex;
+		queryIndex += 1;
+		if (queryIndex === query.length) {
+			const spanPenalty = valueIndex - firstMatchIndex + 1 - query.length;
+			const lengthPenalty = Math.min(64, value.length - query.length);
+			return firstMatchIndex * 2 + gapPenalty * 3 + spanPenalty + lengthPenalty;
+		}
+	}
+	return null;
+}
+function lengthPenalty(value, query) {
+	return Math.min(64, Math.max(0, value.length - query.length));
+}
+function findBoundaryMatchIndex(value, query, boundaryMarkers) {
+	let bestIndex = null;
+	for (const marker of boundaryMarkers) {
+		const index = value.indexOf(`${marker}${query}`);
+		if (index === -1) continue;
+		const matchIndex = index + marker.length;
+		if (bestIndex === null || matchIndex < bestIndex) bestIndex = matchIndex;
+	}
+	return bestIndex;
+}
+/**
+* Scores how well `value` matches `query` using tiered match strategies.
+*
+* **Expects pre-normalized inputs**: both `value` and `query` must already be
+* trimmed and lowercased (e.g. via {@link normalizeSearchQuery}).
+*/
+function scoreQueryMatch(input) {
+	const { value, query } = input;
+	if (!value || !query) return null;
+	if (value === query) return input.exactBase;
+	if (input.prefixBase !== void 0 && value.startsWith(query)) return input.prefixBase + lengthPenalty(value, query);
+	if (input.boundaryBase !== void 0) {
+		const boundaryIndex = findBoundaryMatchIndex(value, query, input.boundaryMarkers ?? [
+			" ",
+			"-",
+			"_",
+			"/"
+		]);
+		if (boundaryIndex !== null) return input.boundaryBase + boundaryIndex * 2 + lengthPenalty(value, query);
+	}
+	if (input.includesBase !== void 0) {
+		const includesIndex = value.indexOf(query);
+		if (includesIndex !== -1) return input.includesBase + includesIndex * 2 + lengthPenalty(value, query);
+	}
+	if (input.fuzzyBase !== void 0) {
+		const fuzzyScore = scoreSubsequenceMatch(value, query);
+		if (fuzzyScore !== null) return input.fuzzyBase + fuzzyScore;
+	}
+	return null;
+}
+function compareRankedSearchResults(left, right) {
+	const scoreDelta = left.score - right.score;
+	if (scoreDelta !== 0) return scoreDelta;
+	return left.tieBreaker.localeCompare(right.tieBreaker);
+}
+function findInsertionIndex(rankedEntries, candidate) {
+	let low = 0;
+	let high = rankedEntries.length;
+	while (low < high) {
+		const middle = low + Math.floor((high - low) / 2);
+		const current = rankedEntries[middle];
+		if (!current) break;
+		if (compareRankedSearchResults(candidate, current) < 0) high = middle;
+		else low = middle + 1;
+	}
+	return low;
+}
+function insertRankedSearchResult(rankedEntries, candidate, limit) {
+	if (limit <= 0) return;
+	const insertionIndex = findInsertionIndex(rankedEntries, candidate);
+	if (rankedEntries.length < limit) {
+		rankedEntries.splice(insertionIndex, 0, candidate);
+		return;
+	}
+	if (insertionIndex >= limit) return;
+	rankedEntries.splice(insertionIndex, 0, candidate);
+	rankedEntries.pop();
+}
+//#endregion
+export { compareRankedSearchResults, insertRankedSearchResult, normalizeSearchQuery, scoreQueryMatch, scoreSubsequenceMatch };

package/dist/shared/semver.d.ts

@@ -0,0 +1,23 @@
+//#region upstream-t3code/packages/shared/src/semver.d.ts
+interface ParsedSemver {
+  readonly major: number;
+  readonly minor: number;
+  readonly patch: number;
+  readonly prerelease: ReadonlyArray<string>;
+}
+declare function normalizeSemverVersion(version: string): string;
+declare function parseSemver(value: string): ParsedSemver | null;
+declare function compareSemverVersions(left: string, right: string): number;
+/**
+ * Small semver range checker for CLI/runtime gates.
+ *
+ * Keep the function body valid plain JavaScript: SSH startup stringifies this
+ * function and runs it on remote Node versions before TypeScript support is known.
+ *
+ * @param rawVersion Version string, with or without a leading `v`.
+ * @param range Space-separated comparators, with `||` range groups.
+ * @returns Whether `rawVersion` satisfies the supported range syntax.
+ */
+declare const satisfiesSemverRange: (rawVersion: string, range: string) => boolean;
+//#endregion
+export { compareSemverVersions, normalizeSemverVersion, parseSemver, satisfiesSemverRange };

package/dist/shared/semver.js

@@ -0,0 +1,124 @@
+//#region upstream-t3code/packages/shared/src/semver.ts
+const SEMVER_NUMBER_SEGMENT = /^\d+$/;
+function normalizeSemverVersion(version) {
+	const [main, prerelease] = version.trim().split("-", 2);
+	const segments = [];
+	for (const segment of (main ?? "").split(".")) {
+		const trimmed = segment.trim();
+		if (trimmed.length > 0) segments.push(trimmed);
+	}
+	if (segments.length === 2) segments.push("0");
+	return prerelease ? `${segments.join(".")}-${prerelease}` : segments.join(".");
+}
+function parseSemver(value) {
+	const [main = "", prerelease] = normalizeSemverVersion(value).replace(/^v/, "").split("-", 2);
+	const segments = main.split(".");
+	if (segments.length !== 3) return null;
+	const [majorSegment, minorSegment, patchSegment] = segments;
+	if (majorSegment === void 0 || minorSegment === void 0 || patchSegment === void 0) return null;
+	if (!SEMVER_NUMBER_SEGMENT.test(majorSegment) || !SEMVER_NUMBER_SEGMENT.test(minorSegment) || !SEMVER_NUMBER_SEGMENT.test(patchSegment)) return null;
+	const major = Number.parseInt(majorSegment, 10);
+	const minor = Number.parseInt(minorSegment, 10);
+	const patch = Number.parseInt(patchSegment, 10);
+	if (![
+		major,
+		minor,
+		patch
+	].every(Number.isInteger)) return null;
+	return {
+		major,
+		minor,
+		patch,
+		prerelease: parsePrereleaseSegments(prerelease)
+	};
+}
+function parsePrereleaseSegments(prerelease) {
+	if (prerelease === void 0) return [];
+	const segments = [];
+	for (const segment of prerelease.split(".")) {
+		const trimmed = segment.trim();
+		if (trimmed.length > 0) segments.push(trimmed);
+	}
+	return segments;
+}
+function comparePrereleaseIdentifier(left, right) {
+	const leftNumeric = SEMVER_NUMBER_SEGMENT.test(left);
+	const rightNumeric = SEMVER_NUMBER_SEGMENT.test(right);
+	if (leftNumeric && rightNumeric) return Number.parseInt(left, 10) - Number.parseInt(right, 10);
+	if (leftNumeric) return -1;
+	if (rightNumeric) return 1;
+	return left.localeCompare(right);
+}
+function compareSemverVersions(left, right) {
+	const parsedLeft = parseSemver(left);
+	const parsedRight = parseSemver(right);
+	if (!parsedLeft || !parsedRight) return left.localeCompare(right);
+	if (parsedLeft.major !== parsedRight.major) return parsedLeft.major - parsedRight.major;
+	if (parsedLeft.minor !== parsedRight.minor) return parsedLeft.minor - parsedRight.minor;
+	if (parsedLeft.patch !== parsedRight.patch) return parsedLeft.patch - parsedRight.patch;
+	if (parsedLeft.prerelease.length === 0 && parsedRight.prerelease.length === 0) return 0;
+	if (parsedLeft.prerelease.length === 0) return 1;
+	if (parsedRight.prerelease.length === 0) return -1;
+	const length = Math.max(parsedLeft.prerelease.length, parsedRight.prerelease.length);
+	for (let index = 0; index < length; index += 1) {
+		const leftIdentifier = parsedLeft.prerelease[index];
+		const rightIdentifier = parsedRight.prerelease[index];
+		if (leftIdentifier === void 0) return -1;
+		if (rightIdentifier === void 0) return 1;
+		const comparison = comparePrereleaseIdentifier(leftIdentifier, rightIdentifier);
+		if (comparison !== 0) return comparison;
+	}
+	return 0;
+}
+/**
+* Small semver range checker for CLI/runtime gates.
+*
+* Keep the function body valid plain JavaScript: SSH startup stringifies this
+* function and runs it on remote Node versions before TypeScript support is known.
+*
+* @param rawVersion Version string, with or without a leading `v`.
+* @param range Space-separated comparators, with `||` range groups.
+* @returns Whether `rawVersion` satisfies the supported range syntax.
+*/
+const satisfiesSemverRange = function satisfiesSemverRange(rawVersion, range) {
+	const versionMatch = String(rawVersion).trim().replace(/^v/, "").match(/^(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-[0-9A-Za-z.-]+)?$/);
+	if (!versionMatch) return false;
+	const version = {
+		major: Number(versionMatch[1]),
+		minor: Number(versionMatch[2] || 0),
+		patch: Number(versionMatch[3] || 0)
+	};
+	return range.split("||").some((group) => {
+		const comparators = group.trim().split(/\s+/).filter(Boolean);
+		if (comparators.length === 0) return false;
+		return comparators.every((comparator) => {
+			const match = comparator.trim().match(/^(\^|>=|>|<=|<|=)?\s*v?(\d+(?:\.\d+){0,2})$/);
+			if (!match) return false;
+			const targetVersion = match[2];
+			if (targetVersion === void 0) return false;
+			const targetMatch = targetVersion.match(/^(\d+)(?:\.(\d+))?(?:\.(\d+))?$/);
+			if (!targetMatch) return false;
+			const target = {
+				major: Number(targetMatch[1]),
+				minor: Number(targetMatch[2] || 0),
+				patch: Number(targetMatch[3] || 0)
+			};
+			const compared = version.major !== target.major ? version.major > target.major ? 1 : -1 : version.minor !== target.minor ? version.minor > target.minor ? 1 : -1 : version.patch !== target.patch ? version.patch > target.patch ? 1 : -1 : 0;
+			switch (match[1] || "=") {
+				case "^":
+					if (compared < 0) return false;
+					if (target.major > 0) return version.major === target.major;
+					if (target.minor > 0) return version.major === 0 && version.minor === target.minor;
+					return version.major === 0 && version.minor === 0 && version.patch === target.patch;
+				case ">=": return compared >= 0;
+				case ">": return compared > 0;
+				case "<=": return compared <= 0;
+				case "<": return compared < 0;
+				case "=": return compared === 0;
+				default: return false;
+			}
+		});
+	});
+};
+//#endregion
+export { compareSemverVersions, normalizeSemverVersion, parseSemver, satisfiesSemverRange };

package/dist/shared/serverSettings.d.ts

@@ -0,0 +1,19 @@
+import { A_ as ModelSelection, i_ as ServerSettings, ou as ServerProvider, s_ as ServerSettingsPatch } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/serverSettings.d.ts
+declare function isModelSelectionProviderEnabled(settings: ServerSettings, selection: ModelSelection): boolean;
+declare function resolveSourceControlWriterModelSelection(settings: ServerSettings, providers?: ReadonlyArray<ServerProvider>): ModelSelection;
+interface PersistedServerObservabilitySettings {
+  readonly otlpTracesUrl: string | undefined;
+  readonly otlpMetricsUrl: string | undefined;
+}
+declare function normalizePersistedServerSettingString(value: string | null | undefined): string | undefined;
+declare function extractPersistedServerObservabilitySettings(input: {
+  readonly observability?: {
+    readonly otlpTracesUrl?: string;
+    readonly otlpMetricsUrl?: string;
+  };
+}): PersistedServerObservabilitySettings;
+declare function parsePersistedServerObservabilitySettings(raw: string): PersistedServerObservabilitySettings;
+declare function applyServerSettingsPatch(current: ServerSettings, patch: ServerSettingsPatch): ServerSettings;
+//#endregion
+export { PersistedServerObservabilitySettings, applyServerSettingsPatch, extractPersistedServerObservabilitySettings, isModelSelectionProviderEnabled, normalizePersistedServerSettingString, parsePersistedServerObservabilitySettings, resolveSourceControlWriterModelSelection };

package/dist/shared/serverSettings.js

@@ -0,0 +1,103 @@
+import { Bk as isSome, N as createModelSelection, US as isProviderDriverKind, Yp as ServerSettings, aE as decodeUnknownOption, c as resolveBackgroundActivitySettings, g as fromLenientJson, i as getBackgroundActivityBaseProfile, mp as isProviderAvailable, o as normalizeBackgroundActivitySettings, s as normalizeServerBackgroundActivitySettings, u as deepMerge } from "../shared.js";
+const decodeServerSettingsJson = decodeUnknownOption(fromLenientJson(ServerSettings));
+const getLegacyProviderSettings = (settings, provider) => settings.providers[provider];
+function isModelSelectionProviderEnabled(settings, selection) {
+	const instanceConfig = settings.providerInstances[selection.instanceId];
+	if (instanceConfig !== void 0) return instanceConfig.enabled ?? true;
+	return isProviderDriverKind(selection.instanceId) && getLegacyProviderSettings(settings, selection.instanceId)?.enabled === true;
+}
+function resolveSourceControlWriterModelSelection(settings, providers) {
+	const selection = settings.sourceControlWriterModelSelection;
+	if (!selection || !isModelSelectionProviderEnabled(settings, selection)) return settings.textGenerationModelSelection;
+	if (providers === void 0) return selection;
+	const provider = providers.find((candidate) => candidate.instanceId === selection.instanceId);
+	return provider?.enabled === true && isProviderAvailable(provider) ? selection : settings.textGenerationModelSelection;
+}
+function normalizePersistedServerSettingString(value) {
+	const trimmed = value?.trim();
+	return trimmed && trimmed.length > 0 ? trimmed : void 0;
+}
+function extractPersistedServerObservabilitySettings(input) {
+	return {
+		otlpTracesUrl: normalizePersistedServerSettingString(input.observability?.otlpTracesUrl),
+		otlpMetricsUrl: normalizePersistedServerSettingString(input.observability?.otlpMetricsUrl)
+	};
+}
+function parsePersistedServerObservabilitySettings(raw) {
+	const decoded = decodeServerSettingsJson(raw);
+	if (isSome(decoded)) return extractPersistedServerObservabilitySettings(decoded.value);
+	return {
+		otlpTracesUrl: void 0,
+		otlpMetricsUrl: void 0
+	};
+}
+function shouldReplaceTextGenerationModelSelection(patch) {
+	return Boolean(patch && (patch.instanceId !== void 0 || patch.model !== void 0));
+}
+function mergeModelSelectionOptionsById(input) {
+	if (input.patch === void 0) return input.current ? [...input.current] : void 0;
+	if (input.patch.length === 0) return;
+	const merged = new Map((input.current ?? []).map((selection) => [selection.id, selection.value]));
+	for (const selection of input.patch) merged.set(selection.id, selection.value);
+	return [...merged.entries()].map(([id, value]) => ({
+		id,
+		value
+	}));
+}
+function applyServerSettingsPatch(current, patch) {
+	const selectionPatch = patch.textGenerationModelSelection;
+	const { automaticGitFetchInterval, providerHealthRefreshInterval, backgroundActivityProfile, backgroundActivity, ...patchForMerge } = patch;
+	const currentBackgroundActivity = normalizeServerBackgroundActivitySettings(current);
+	const backgroundActivityPatch = backgroundActivityProfile !== void 0 ? {
+		schemaVersion: 1,
+		profile: automaticGitFetchInterval !== void 0 || providerHealthRefreshInterval !== void 0 ? "custom" : backgroundActivityProfile,
+		...automaticGitFetchInterval !== void 0 || providerHealthRefreshInterval !== void 0 ? { baseProfile: backgroundActivityProfile } : {},
+		overrides: {
+			...automaticGitFetchInterval !== void 0 ? { automaticGitFetchInterval } : {},
+			...providerHealthRefreshInterval !== void 0 ? { providerHealthRefreshInterval } : {}
+		}
+	} : automaticGitFetchInterval !== void 0 || providerHealthRefreshInterval !== void 0 ? {
+		schemaVersion: 1,
+		profile: "custom",
+		baseProfile: getBackgroundActivityBaseProfile(currentBackgroundActivity),
+		overrides: {
+			...currentBackgroundActivity.profile === "custom" ? currentBackgroundActivity.overrides : {},
+			...automaticGitFetchInterval !== void 0 ? { automaticGitFetchInterval } : {},
+			...providerHealthRefreshInterval !== void 0 ? { providerHealthRefreshInterval } : {}
+		}
+	} : void 0;
+	const nextWithReplacementsBase = {
+		...deepMerge(current, patchForMerge),
+		...backgroundActivity !== void 0 ? { backgroundActivity: {
+			...deepMerge(currentBackgroundActivity, backgroundActivity),
+			...backgroundActivity.overrides !== void 0 ? { overrides: backgroundActivity.overrides } : {}
+		} } : { backgroundActivity: currentBackgroundActivity },
+		...backgroundActivity === void 0 && backgroundActivityPatch !== void 0 ? { backgroundActivity: backgroundActivityPatch } : {},
+		...patch.providerInstances !== void 0 ? { providerInstances: patch.providerInstances } : {},
+		...patch.sourceControlWriterModelSelection !== void 0 ? { sourceControlWriterModelSelection: patch.sourceControlWriterModelSelection } : {},
+		...automaticGitFetchInterval !== void 0 ? { automaticGitFetchInterval } : {},
+		...providerHealthRefreshInterval !== void 0 ? { providerHealthRefreshInterval } : {}
+	};
+	const normalizedBackgroundActivity = normalizeBackgroundActivitySettings(nextWithReplacementsBase.backgroundActivity);
+	const resolvedBackgroundActivity = resolveBackgroundActivitySettings(normalizedBackgroundActivity);
+	const nextWithReplacements = {
+		...nextWithReplacementsBase,
+		backgroundActivity: normalizedBackgroundActivity,
+		automaticGitFetchInterval: resolvedBackgroundActivity.automaticGitFetchInterval,
+		providerHealthRefreshInterval: resolvedBackgroundActivity.providerHealthRefreshInterval,
+		backgroundActivityProfile: resolvedBackgroundActivity.profile
+	};
+	if (!selectionPatch) return nextWithReplacements;
+	const instanceId = selectionPatch.instanceId ?? current.textGenerationModelSelection.instanceId;
+	const model = selectionPatch.model ?? current.textGenerationModelSelection.model;
+	const options = shouldReplaceTextGenerationModelSelection(selectionPatch) ? selectionPatch.options : mergeModelSelectionOptionsById({
+		current: current.textGenerationModelSelection.options,
+		patch: selectionPatch.options
+	});
+	return {
+		...nextWithReplacements,
+		textGenerationModelSelection: createModelSelection(instanceId, model, options)
+	};
+}
+//#endregion
+export { applyServerSettingsPatch, extractPersistedServerObservabilitySettings, isModelSelectionProviderEnabled, normalizePersistedServerSettingString, parsePersistedServerObservabilitySettings, resolveSourceControlWriterModelSelection };

package/dist/shared/shell.d.ts

@@ -0,0 +1,51 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Path from "effect/Path";
+import * as FileSystem from "effect/FileSystem";
+//#region upstream-t3code/packages/shared/src/shell.d.ts
+type ExecFileSyncLike = (file: string, args: ReadonlyArray<string>, options: {
+  encoding: "utf8";
+  timeout: number;
+}) => string;
+interface CommandAvailabilityOptions {
+  readonly env?: NodeJS.ProcessEnv;
+  readonly extendEnv?: boolean;
+}
+type CommandAvailabilityChecker = (command: string, options?: CommandAvailabilityOptions) => Effect.Effect<boolean, never, FileSystem.FileSystem | Path.Path>;
+declare const CommandResolutionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "CommandResolutionError";
+} & Readonly<A>;
+declare class CommandResolutionError extends CommandResolutionError_base<{
+  readonly command: string;
+  readonly reason: "not-found";
+}> {}
+interface ResolvedSpawnCommand {
+  readonly command: string;
+  readonly args: ReadonlyArray<string>;
+  readonly shell: boolean;
+}
+type SpawnExecutableResolver = (command: string, platform: NodeJS.Platform, env: NodeJS.ProcessEnv) => string | undefined;
+declare const SpawnExecutableResolution: Context.Reference<SpawnExecutableResolver>;
+interface WindowsEnvironmentProbeOptions {
+  readonly loadProfile?: boolean;
+}
+declare function listLoginShellCandidates(platform: NodeJS.Platform, shell: string | undefined, userShell?: string | undefined): ReadonlyArray<string>;
+declare function extractPathFromShellOutput(output: string): string | null;
+declare function readPathFromLoginShell(shell: string, execFile?: ExecFileSyncLike): string | undefined;
+declare function readPathFromLaunchctl(execFile?: ExecFileSyncLike): string | undefined;
+declare function mergePathEntries(preferredPath: string | undefined, inheritedPath: string | undefined, platform: NodeJS.Platform): string | undefined;
+type ShellEnvironmentReader = (shell: string, names: ReadonlyArray<string>, execFile?: ExecFileSyncLike) => Partial<Record<string, string>>;
+declare const readEnvironmentFromLoginShell: ShellEnvironmentReader;
+type WindowsShellEnvironmentReader = (names: ReadonlyArray<string>, options?: WindowsEnvironmentProbeOptions) => Partial<Record<string, string>>;
+declare const WindowsShellEnvironment: Context.Reference<WindowsShellEnvironmentReader>;
+declare const CommandAvailability: Context.Reference<CommandAvailabilityChecker>;
+declare function readEnvironmentFromWindowsShell(names: ReadonlyArray<string>, execFile?: ExecFileSyncLike): Partial<Record<string, string>>;
+declare function readEnvironmentFromWindowsShell(names: ReadonlyArray<string>, options?: WindowsEnvironmentProbeOptions, execFile?: ExecFileSyncLike): Partial<Record<string, string>>;
+declare function mergePathValues(preferredPath: string | undefined, inheritedPath: string | undefined, platform: NodeJS.Platform): string | undefined;
+declare const resolveCommandPath: (command: string, options?: CommandAvailabilityOptions | undefined) => Effect.Effect<string, CommandResolutionError, FileSystem.FileSystem | Path.Path>;
+declare const resolveSpawnCommand: (command: string, args: readonly string[], options?: CommandAvailabilityOptions | undefined) => Effect.Effect<ResolvedSpawnCommand, never, never>;
+declare const isCommandAvailable: (command: string, options?: CommandAvailabilityOptions | undefined) => Effect.Effect<boolean, never, FileSystem.FileSystem | Path.Path>;
+declare function resolveKnownWindowsCliDirs(env: NodeJS.ProcessEnv): ReadonlyArray<string>;
+declare const resolveWindowsEnvironment: (env: NodeJS.ProcessEnv) => Effect.Effect<Partial<NodeJS.ProcessEnv>, never, FileSystem.FileSystem | Path.Path>;
+//#endregion
+export { CommandAvailability, CommandAvailabilityChecker, CommandAvailabilityOptions, CommandResolutionError, ResolvedSpawnCommand, ShellEnvironmentReader, SpawnExecutableResolution, SpawnExecutableResolver, WindowsEnvironmentProbeOptions, WindowsShellEnvironment, WindowsShellEnvironmentReader, extractPathFromShellOutput, isCommandAvailable, listLoginShellCandidates, mergePathEntries, mergePathValues, readEnvironmentFromLoginShell, readEnvironmentFromWindowsShell, readPathFromLaunchctl, readPathFromLoginShell, resolveCommandPath, resolveKnownWindowsCliDirs, resolveSpawnCommand, resolveWindowsEnvironment };