dsh-pstack 0.3.0-beta.1 → 0.3.1

package/dist/budget.mjs

@@ -0,0 +1,293 @@
+import { renderRouteValue } from "./route.mjs";
+import { WireTypeError } from "./wire-error.mjs";
+// src/budget.ts
+const BUDGET_TIERS = [
+	"unlimited",
+	"large",
+	"medium",
+	"small"
+];
+const BUDGET_TARGETS = {
+	unlimited: "max",
+	large: "xhigh",
+	medium: "high",
+	small: "medium"
+};
+const EFFORT_LADDER = [
+	"off",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+var BudgetPlanError = class extends Error {
+	code;
+	detail;
+	constructor(code, detail) {
+		super(detail === void 0 ? code : `${code}: ${detail}`);
+		this.code = code;
+		this.detail = detail;
+		this.name = "BudgetPlanError";
+	}
+};
+/** The single matcher for a `# budget:` line. Captures the value after the colon. */
+const BUDGET_LINE = /^[ \t]*#[ \t]*budget[ \t]*:[ \t]*(.*)$/i;
+/** Return the value after `# budget:`, or `undefined` when the line is not a budget line. */
+function budgetLineValue(line) {
+	const match = BUDGET_LINE.exec(line);
+	return match === null ? void 0 : (match[1] ?? "").trim();
+}
+/** Read a tier from the existing `# budget: <tier> (<target>)` line. */
+function budgetTierFromLabel(raw) {
+	if (raw === void 0) return void 0;
+	return /^\s*(unlimited|large|medium|small)\b/i.exec(raw)?.[1]?.toLowerCase();
+}
+/** Render the persisted budget value that follows `# budget:`. */
+function budgetValueFor(tier) {
+	return `${tier} (${BUDGET_TARGETS[tier]})`;
+}
+function budgetLineFor(tier) {
+	return `# budget: ${budgetValueFor(tier)}`;
+}
+/** Parse and validate a budget apply request at the wire boundary. */
+function parseBudgetApplyRequest(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new WireTypeError("request", "an object");
+	const record = value;
+	if (typeof record["tier"] !== "string" || !BUDGET_TIERS.includes(record["tier"])) throw new WireTypeError("request.tier", `one of ${BUDGET_TIERS.join(", ")}`);
+	if (record["scope"] !== "concrete" && record["scope"] !== "unconfigured") throw new WireTypeError("request.scope", "\"concrete\" or \"unconfigured\"");
+	const rawModel = record["defaultModel"];
+	let defaultModel;
+	if (rawModel !== void 0) {
+		if (typeof rawModel !== "object" || rawModel === null || Array.isArray(rawModel)) throw new WireTypeError("request.defaultModel", "an object when present");
+		const model = rawModel;
+		if (typeof model["provider"] !== "string" || model["provider"].trim() === "") throw new WireTypeError("request.defaultModel.provider", "a non-empty string");
+		if (typeof model["model"] !== "string" || model["model"].trim() === "") throw new WireTypeError("request.defaultModel.model", "a non-empty string");
+		defaultModel = {
+			provider: model["provider"].trim(),
+			model: model["model"].trim()
+		};
+	}
+	if (record["scope"] === "unconfigured" && defaultModel === void 0) throw new WireTypeError("request.defaultModel", "required for the unconfigured scope");
+	return {
+		tier: record["tier"],
+		scope: record["scope"],
+		...defaultModel === void 0 ? {} : { defaultModel }
+	};
+}
+/** Whether a plan row must be fixed before a budget can be applied. */
+function isBudgetRowBlocked(row) {
+	return row.status === "needs-choice" || row.detail?.kind === "missing-model";
+}
+/** Plan every role change without touching the filesystem. */
+function planBudget(roles, catalogue, request) {
+	const defaultModel = request.scope === "unconfigured" ? resolveDefaultModel(catalogue, request.defaultModel) : void 0;
+	const warnings = [];
+	const rows = roles.map((role) => planRole(role, request, defaultModel, catalogue, warnings));
+	return {
+		tier: request.tier,
+		scope: request.scope,
+		budgetLine: budgetLineFor(request.tier),
+		rows,
+		warnings
+	};
+}
+function updateBudgetText(text, line) {
+	const bom = text.startsWith("") ? "" : "";
+	const body = bom === "" ? text : text.slice(1);
+	const eol = body.includes("\r\n") ? "\r\n" : "\n";
+	const lines = body.split(/\r?\n/);
+	const indexes = lines.flatMap((value, index) => BUDGET_LINE.test(value) ? [index] : []);
+	if (indexes.length === 0) return bom + (body === "" ? `${line}${eol}` : `${line}${eol}${body}`);
+	const first = indexes[0];
+	return bom + lines.flatMap((value, index) => {
+		if (!indexes.includes(index)) return [value];
+		return index === first ? [line] : [];
+	}).join(eol);
+}
+/** Apply a plan to role file text and return an untouched string when nothing changed. */
+function renderBudgetText(text, plan, updateRole) {
+	let next = text;
+	for (const row of plan.rows) {
+		if (row.status === "skipped") continue;
+		if (routeSignature(row.routes) === routeSignature(row.previous)) continue;
+		next = updateRole(next, row.key, renderRouteValue(row.routes));
+	}
+	return updateBudgetText(next, plan.budgetLine);
+}
+function planRole(role, request, defaultModel, catalogue, warnings) {
+	const previous = role.routes;
+	if (role.hasIssues === true) return {
+		key: role.key,
+		status: "skipped",
+		previous,
+		routes: previous
+	};
+	if (!role.configured) {
+		if (request.scope !== "unconfigured" || defaultModel === void 0) return {
+			key: role.key,
+			status: "skipped",
+			previous,
+			routes: previous
+		};
+		const effort = effortFor(defaultModel, request.tier);
+		if (role.autoPanel) warnings.push({
+			kind: "auto-panel",
+			role: role.key
+		});
+		return {
+			key: role.key,
+			status: statusForNew(effort),
+			previous,
+			routes: [routeFor(defaultModel, effort.effort)],
+			...effort.detail === void 0 ? {} : { detail: effort.detail }
+		};
+	}
+	if (request.scope !== "concrete") return {
+		key: role.key,
+		status: "skipped",
+		previous,
+		routes: previous
+	};
+	if (previous.every((route) => route.kind === "inherit")) return {
+		key: role.key,
+		status: "skipped",
+		previous,
+		routes: previous
+	};
+	let aggregate = "unchanged";
+	let detail;
+	const routes = previous.map((route) => {
+		if (route.kind === "inherit") return route;
+		const model = findCatalogueModel(catalogue, route.provider, route.model);
+		if (model === void 0) {
+			aggregate = mergeStatus(aggregate, "custom");
+			detail = preferDetail(detail, {
+				kind: "missing-model",
+				provider: route.provider,
+				model: route.model
+			});
+			return route;
+		}
+		const effort = effortFor(model, request.tier);
+		aggregate = mergeStatus(aggregate, statusForExisting(effort, route));
+		detail = preferDetail(detail, effort.detail);
+		if (effort.effort === void 0) return route;
+		return {
+			...route,
+			effort: effort.effort
+		};
+	});
+	return {
+		key: role.key,
+		status: aggregate,
+		previous,
+		routes,
+		...detail === void 0 ? {} : { detail }
+	};
+}
+function statusForNew(effort) {
+	if (effort.status === "exact") return "changed";
+	if (effort.status === "fallback") return "fallback";
+	return effort.status;
+}
+function statusForExisting(effort, route) {
+	if (effort.status === "exact" && route.effort === effort.effort) return "unchanged";
+	if (effort.status === "exact") return "changed";
+	if (effort.status === "fallback") return "fallback";
+	return effort.status;
+}
+function mergeStatus(left, right) {
+	const order = {
+		unchanged: 0,
+		changed: 1,
+		fallback: 2,
+		unsupported: 3,
+		custom: 4,
+		"needs-choice": 5,
+		skipped: 6
+	};
+	return order[right] > order[left] ? right : left;
+}
+function preferDetail(current, next) {
+	if (next === void 0) return current;
+	if (current === void 0) return next;
+	const order = {
+		fallback: 0,
+		custom: 1,
+		unsupported: 2,
+		"needs-choice": 3,
+		"missing-model": 4
+	};
+	return order[next.kind] > order[current.kind] ? next : current;
+}
+function effortFor(model, tier) {
+	if (model.efforts.length === 0) return {
+		status: "unsupported",
+		detail: { kind: "unsupported" }
+	};
+	const target = BUDGET_TARGETS[tier];
+	if (model.efforts.includes(target)) return {
+		status: "exact",
+		effort: target
+	};
+	const targetIndex = EFFORT_LADDER.indexOf(target);
+	const known = model.efforts.map((effort) => ({
+		effort,
+		index: EFFORT_LADDER.indexOf(effort)
+	})).filter((entry) => entry.index >= 0);
+	if (known.length === 0) return {
+		status: "custom",
+		detail: { kind: "custom" }
+	};
+	const lower = known.filter((entry) => entry.index <= targetIndex).sort((left, right) => right.index - left.index);
+	if (lower[0] !== void 0) return {
+		status: "fallback",
+		effort: lower[0].effort,
+		detail: {
+			kind: "fallback",
+			effort: lower[0].effort
+		}
+	};
+	return {
+		status: "needs-choice",
+		detail: { kind: "needs-choice" }
+	};
+}
+function resolveDefaultModel(catalogue, choice) {
+	if (choice === void 0) throw new BudgetPlanError("no-default-model");
+	const provider = catalogue.providers.find((entry) => entry.provider === choice.provider);
+	if (provider === void 0) throw new BudgetPlanError("provider-not-found", choice.provider);
+	if (provider.error !== void 0) throw new BudgetPlanError("provider-discovery", choice.provider);
+	const model = provider.models.find((entry) => entry.id === choice.model);
+	if (model === void 0) throw new BudgetPlanError("model-not-found", `${choice.provider}/${choice.model}`);
+	if (model.error !== void 0) throw new BudgetPlanError("model-discovery", `${choice.provider}/${choice.model}`);
+	return model;
+}
+function findCatalogueModel(catalogue, providerId, modelId) {
+	const provider = catalogue.providers.find((entry) => entry.provider === providerId);
+	if (provider === void 0 || provider.error !== void 0) return void 0;
+	const model = provider.models.find((entry) => entry.id === modelId);
+	if (model === void 0 || model.error !== void 0) return void 0;
+	return model;
+}
+function routeFor(model, effort) {
+	return {
+		kind: "route",
+		provider: splitRoute(model.route).provider,
+		model: model.id,
+		...effort === void 0 ? {} : { effort }
+	};
+}
+function splitRoute(route) {
+	const slash = route.indexOf("/");
+	if (slash <= 0) throw new Error(`invalid model route "${route}"`);
+	return {
+		provider: route.slice(0, slash),
+		model: route.slice(slash + 1)
+	};
+}
+function routeSignature(routes) {
+	return JSON.stringify(routes);
+}
+export { BUDGET_LINE, BUDGET_TARGETS, BUDGET_TIERS, BudgetPlanError, budgetLineFor, budgetLineValue, budgetTierFromLabel, budgetValueFor, isBudgetRowBlocked, parseBudgetApplyRequest, planBudget, renderBudgetText, updateBudgetText };

package/dist/catalogue-wgVaGeUx.d.mts

@@ -0,0 +1,27 @@
+import { JsonSchemaNode } from "@deepseek-ai/dsh-tools";
+interface ModelEntry {
+  readonly route: string;
+  readonly id: string;
+  readonly name: string;
+  readonly description?: string;
+  readonly contextWindow?: number;
+  readonly maxTokens?: number;
+  readonly efforts: readonly string[];
+  readonly defaultEffort?: string;
+  readonly error?: string;
+}
+interface ProviderEntry {
+  readonly provider: string;
+  readonly name: string;
+  readonly models: readonly ModelEntry[];
+  readonly error?: string;
+}
+interface CatalogueResult {
+  readonly providers: readonly ProviderEntry[];
+  readonly truncated: boolean;
+  readonly providerFilter?: string;
+}
+declare const CATALOGUE_OUTPUT_SCHEMA: JsonSchemaNode;
+/** Parse the live model catalogue returned by the Host. */
+declare function parseCatalogueResult(value: unknown): CatalogueResult;
+export { parseCatalogueResult as a, ProviderEntry as i, CatalogueResult as n, ModelEntry as r, CATALOGUE_OUTPUT_SCHEMA as t };

package/dist/catalogue.d.mts

@@ -0,0 +1,2 @@
+import { a as parseCatalogueResult, i as ProviderEntry, n as CatalogueResult, r as ModelEntry, t as CATALOGUE_OUTPUT_SCHEMA } from "./catalogue-wgVaGeUx.mjs";
+export { CATALOGUE_OUTPUT_SCHEMA, CatalogueResult, ModelEntry, ProviderEntry, parseCatalogueResult };

package/dist/catalogue.mjs

@@ -0,0 +1,116 @@
+import { WireTypeError } from "./wire-error.mjs";
+// src/catalogue.ts
+const CATALOGUE_OUTPUT_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	properties: {
+		providers: {
+			type: "array",
+			items: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					provider: { type: "string" },
+					name: { type: "string" },
+					error: { type: "string" },
+					models: {
+						type: "array",
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								route: { type: "string" },
+								id: { type: "string" },
+								name: { type: "string" },
+								description: { type: "string" },
+								contextWindow: { type: "integer" },
+								maxTokens: { type: "integer" },
+								efforts: {
+									type: "array",
+									items: { type: "string" }
+								},
+								defaultEffort: { type: "string" },
+								error: { type: "string" }
+							},
+							required: [
+								"route",
+								"id",
+								"name",
+								"efforts"
+							]
+						}
+					}
+				},
+				required: [
+					"provider",
+					"name",
+					"models"
+				]
+			}
+		},
+		truncated: { type: "boolean" },
+		providerFilter: { type: "string" }
+	},
+	required: ["providers", "truncated"]
+};
+function parseRecord(value, path) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new WireTypeError(path, "an object");
+	return value;
+}
+function optionalString(record, key, path) {
+	const value = record[key];
+	if (value !== void 0 && typeof value !== "string") throw new WireTypeError(`${path}.${key}`, "a string when present");
+	return value;
+}
+function optionalInteger(record, key, path) {
+	const value = record[key];
+	if (value !== void 0 && !Number.isSafeInteger(value)) throw new WireTypeError(`${path}.${key}`, "an integer when present");
+	return value;
+}
+/** Parse the live model catalogue returned by the Host. */
+function parseCatalogueResult(value) {
+	const record = parseRecord(value, "catalogue");
+	if (!Array.isArray(record["providers"])) throw new WireTypeError("catalogue.providers", "an array");
+	if (typeof record["truncated"] !== "boolean") throw new WireTypeError("catalogue.truncated", "a boolean");
+	const providerFilter = optionalString(record, "providerFilter", "catalogue");
+	return {
+		providers: record["providers"].map((provider, index) => {
+			const path = `catalogue.providers[${index}]`;
+			const entry = parseRecord(provider, path);
+			if (typeof entry["provider"] !== "string" || typeof entry["name"] !== "string") throw new WireTypeError(path, "provider and name strings");
+			if (!Array.isArray(entry["models"])) throw new WireTypeError(`${path}.models`, "an array");
+			const providerError = optionalString(entry, "error", path);
+			return {
+				provider: entry["provider"],
+				name: entry["name"],
+				...providerError === void 0 ? {} : { error: providerError },
+				models: entry["models"].map((model, modelIndex) => {
+					const modelPath = `${path}.models[${modelIndex}]`;
+					const item = parseRecord(model, modelPath);
+					if (typeof item["route"] !== "string" || typeof item["id"] !== "string" || typeof item["name"] !== "string") throw new WireTypeError(modelPath, "route, id, and name strings");
+					const efforts = item["efforts"];
+					if (!Array.isArray(efforts) || efforts.some((effort) => typeof effort !== "string")) throw new WireTypeError(`${modelPath}.efforts`, "an array of strings");
+					const description = optionalString(item, "description", modelPath);
+					const contextWindow = optionalInteger(item, "contextWindow", modelPath);
+					const maxTokens = optionalInteger(item, "maxTokens", modelPath);
+					const defaultEffort = optionalString(item, "defaultEffort", modelPath);
+					const modelError = optionalString(item, "error", modelPath);
+					return {
+						route: item["route"],
+						id: item["id"],
+						name: item["name"],
+						...description === void 0 ? {} : { description },
+						...contextWindow === void 0 ? {} : { contextWindow },
+						...maxTokens === void 0 ? {} : { maxTokens },
+						efforts,
+						...defaultEffort === void 0 ? {} : { defaultEffort },
+						...modelError === void 0 ? {} : { error: modelError }
+					};
+				})
+			};
+		}),
+		truncated: record["truncated"],
+		...typeof providerFilter === "string" ? { providerFilter } : {}
+	};
+}
+export { CATALOGUE_OUTPUT_SCHEMA, parseCatalogueResult };