dsh-pstack 0.2.0-beta.3 → 0.2.1

package/dist/remote.mjs

@@ -0,0 +1,235 @@
+import { a as isRoleKey } from "./role-manifest-79cnFfDM.mjs";
+// src/remote.ts
+/** npm package that owns these methods. */
+const REMOTE_PACKAGE = "dsh-pstack";
+/** Cordis service key and wire namespace of the Host role service. */
+const ROLES_SERVICE = "pstackRoles";
+function jsonCodec(typeSymbol, parse, decode) {
+	return {
+		mode: "strict",
+		typeSymbol,
+		create: () => ({ parse }),
+		...decode === void 0 ? {} : { decode }
+	};
+}
+function parameter(wire, typeSymbol, parse) {
+	return {
+		name: wire,
+		wire,
+		source: "json",
+		codec: jsonCodec(typeSymbol, parse)
+	};
+}
+function parseRecord(value, subject) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError(`${subject} must be an object`);
+	return value;
+}
+function parseRoute(value, subject) {
+	const record = parseRecord(value, subject);
+	if (record["kind"] === "inherit") {
+		const alias = record["alias"] ?? "inherit-parent";
+		if (alias !== "inherit-parent" && alias !== "auto") throw new TypeError(`${subject}.alias must be "inherit-parent" or "auto"`);
+		return {
+			kind: "inherit",
+			alias
+		};
+	}
+	if (record["kind"] !== "route") throw new TypeError(`${subject}.kind is unknown`);
+	const provider = record["provider"];
+	const model = record["model"];
+	const effort = record["effort"];
+	if (typeof provider !== "string" || provider.trim() === "") throw new TypeError(`${subject}.provider must be a non-empty string`);
+	if (typeof model !== "string" || model.trim() === "") throw new TypeError(`${subject}.model must be a non-empty string`);
+	if (effort !== void 0 && (typeof effort !== "string" || effort.trim() === "")) throw new TypeError(`${subject}.effort must be a non-empty string when present`);
+	return {
+		kind: "route",
+		provider,
+		model,
+		...typeof effort === "string" ? { effort } : {}
+	};
+}
+/** Parse one save request from the wire. */
+function parseSaveRoleRequest(value) {
+	const record = parseRecord(value, "the save request");
+	if (typeof record["key"] !== "string") throw new TypeError("the save request must name a role");
+	const routes = record["routes"];
+	if (!Array.isArray(routes)) throw new TypeError("the save request must carry a route list");
+	return {
+		key: record["key"],
+		routes: routes.map((route, index) => parseRoute(route, `routes[${index}]`))
+	};
+}
+function parseRoleFileIssue(value) {
+	const record = parseRecord(value, "a role file issue");
+	if (typeof record["message"] !== "string") throw new TypeError("a role file issue needs a message");
+	const line = record["line"];
+	if (line !== void 0 && typeof line !== "number") throw new TypeError("a role file issue line must be a number");
+	return {
+		...typeof line === "number" ? { line } : {},
+		message: record["message"]
+	};
+}
+function parseRoleView(value, index) {
+	const record = parseRecord(value, `roles[${index}]`);
+	if (typeof record["key"] !== "string" || !isRoleKey(record["key"])) throw new TypeError(`roles[${index}].key is not in the role manifest`);
+	if (record["shape"] !== "single" && record["shape"] !== "list") throw new TypeError(`roles[${index}].shape is unknown`);
+	if (typeof record["configured"] !== "boolean") throw new TypeError(`roles[${index}].configured must be a boolean`);
+	const routes = record["routes"];
+	const issues = record["issues"];
+	if (!Array.isArray(routes) || !Array.isArray(issues)) throw new TypeError(`roles[${index}] must carry routes and issues arrays`);
+	const line = record["line"];
+	return {
+		key: record["key"],
+		shape: record["shape"],
+		configured: record["configured"],
+		...typeof line === "number" ? { line } : {},
+		routes: routes.map((route, routeIndex) => parseRoute(route, `roles[${index}].routes[${routeIndex}]`)),
+		issues: issues.map((issue) => String(issue))
+	};
+}
+/** Parse a role-file snapshot from the wire. */
+function parseRoleFileSnapshot(value) {
+	const record = parseRecord(value, "the role file snapshot");
+	const status = record["status"];
+	if (status !== "missing" && status !== "loaded" && status !== "unreadable") throw new TypeError("the role file snapshot status is unknown");
+	if (typeof record["path"] !== "string") throw new TypeError("the role file snapshot path must be a string");
+	if (typeof record["canSave"] !== "boolean") throw new TypeError("the role file snapshot canSave must be a boolean");
+	const roles = record["roles"];
+	const issues = record["issues"];
+	if (!Array.isArray(roles) || !Array.isArray(issues)) throw new TypeError("the role file snapshot must carry roles and issues arrays");
+	const reason = record["reason"];
+	const budget = record["budget"];
+	return {
+		path: record["path"],
+		status,
+		...typeof reason === "string" ? { reason } : {},
+		...typeof budget === "string" ? { budget } : {},
+		roles: roles.map((role, index) => parseRoleView(role, index)),
+		issues: issues.map(parseRoleFileIssue),
+		canSave: record["canSave"]
+	};
+}
+/** Parse a save result from the wire. */
+function parseSaveRoleResult(value) {
+	const record = parseRecord(value, "the save result");
+	if (record["ok"] === true) return {
+		ok: true,
+		snapshot: parseRoleFileSnapshot(record["snapshot"])
+	};
+	if (record["ok"] === false && typeof record["reason"] === "string") return {
+		ok: false,
+		reason: record["reason"]
+	};
+	throw new TypeError("the save result must be ok with a snapshot or refused with a reason");
+}
+/** Parse the live catalogue the page offers. */
+function parseCatalogue(value) {
+	const record = parseRecord(value, "the catalogue");
+	const providers = record["providers"];
+	if (!Array.isArray(providers)) throw new TypeError("the catalogue must carry providers");
+	if (typeof record["truncated"] !== "boolean") throw new TypeError("the catalogue truncated flag must be a boolean");
+	return {
+		providers: providers.map((provider, index) => {
+			const entry = parseRecord(provider, `providers[${index}]`);
+			if (typeof entry["provider"] !== "string" || typeof entry["name"] !== "string") throw new TypeError(`providers[${index}] needs provider and name strings`);
+			const models = entry["models"];
+			if (!Array.isArray(models)) throw new TypeError(`providers[${index}].models must be an array`);
+			return {
+				provider: entry["provider"],
+				name: entry["name"],
+				...typeof entry["error"] === "string" ? { error: entry["error"] } : {},
+				models: models.map((model, modelIndex) => {
+					const item = parseRecord(model, `providers[${index}].models[${modelIndex}]`);
+					if (typeof item["route"] !== "string" || typeof item["id"] !== "string" || typeof item["name"] !== "string") throw new TypeError(`providers[${index}].models[${modelIndex}] needs route, id, and name strings`);
+					const efforts = item["efforts"];
+					if (!Array.isArray(efforts) || efforts.some((effort) => typeof effort !== "string")) throw new TypeError(`providers[${index}].models[${modelIndex}].efforts must be strings`);
+					return {
+						route: item["route"],
+						id: item["id"],
+						name: item["name"],
+						...typeof item["description"] === "string" ? { description: item["description"] } : {},
+						...typeof item["contextWindow"] === "number" ? { contextWindow: item["contextWindow"] } : {},
+						...typeof item["maxTokens"] === "number" ? { maxTokens: item["maxTokens"] } : {},
+						efforts,
+						...typeof item["defaultEffort"] === "string" ? { defaultEffort: item["defaultEffort"] } : {},
+						...typeof item["error"] === "string" ? { error: item["error"] } : {}
+					};
+				})
+			};
+		}),
+		truncated: record["truncated"]
+	};
+}
+function directMethod(options) {
+	const descriptor = {
+		id: `${REMOTE_PACKAGE}#${ROLES_SERVICE}/${options.method}`,
+		service: ROLES_SERVICE,
+		namespace: ROLES_SERVICE,
+		method: options.method,
+		invocation: { kind: "direct" },
+		parameters: options.parameters,
+		result: options.result,
+		...options.cancellation === true ? { cancellation: { parameter: "signal" } } : {}
+	};
+	const input = { create() {
+		return { parse(value) {
+			const record = parseRecord(value, "the method input");
+			const parsed = {};
+			for (const item of options.parameters) if (record[item.wire] !== void 0) {
+				const codec = item.codec;
+				parsed[item.wire] = codec.create().parse(record[item.wire]);
+			}
+			return parsed;
+		} };
+	} };
+	return {
+		...descriptor,
+		input: () => input,
+		invoke(remote, named, signal) {
+			const namespace = Reflect.get(remote, ROLES_SERVICE);
+			const values = options.parameters.map((item) => named[item.wire]);
+			if (options.cancellation === true) values.push(signal);
+			return namespace[options.method](...values);
+		}
+	};
+}
+const statusMethod = directMethod({
+	method: "status",
+	parameters: [],
+	result: jsonCodec("PstackRoleFileSnapshot", parseRoleFileSnapshot, parseRoleFileSnapshot),
+	invoke: (remote) => remote.pstackRoles.status()
+});
+const catalogueMethod = directMethod({
+	method: "catalogue",
+	parameters: [],
+	result: jsonCodec("PstackRoleCatalogue", parseCatalogue, parseCatalogue),
+	cancellation: true,
+	invoke: (remote, _input, signal) => remote.pstackRoles.catalogue(signal)
+});
+const saveMethod = directMethod({
+	method: "save",
+	parameters: [parameter("request", "PstackSaveRoleRequest", (value) => {
+		parseSaveRoleRequest(value);
+		return value;
+	})],
+	result: jsonCodec("PstackSaveRoleResult", parseSaveRoleResult, parseSaveRoleResult),
+	cancellation: true,
+	invoke: (remote, request, signal) => remote.pstackRoles.save(request, signal)
+});
+/** Mountable contribution the Client passes to `ctx.remote.$mount()`. */
+const pstackRolesRemote = {
+	package: REMOTE_PACKAGE,
+	descriptors: [
+		statusMethod,
+		catalogueMethod,
+		saveMethod
+	],
+	methods: {
+		[`${ROLES_SERVICE}/status`]: statusMethod,
+		[`${ROLES_SERVICE}/catalogue`]: catalogueMethod,
+		[`${ROLES_SERVICE}/save`]: saveMethod
+	}
+};
+/** The same descriptors registered by the Host as its strict definitions. */
+const pstackRolesContribution = pstackRolesRemote;
+export { REMOTE_PACKAGE, ROLES_SERVICE, parseCatalogue, parseRoleFileSnapshot, parseSaveRoleRequest, parseSaveRoleResult, pstackRolesContribution, pstackRolesRemote };

package/dist/role-catalog.d.mts

@@ -0,0 +1,35 @@
+import { _ as ToolsHost, g as ToolDefinition } from "./host-contract-CUPSpeNk.mjs";
+import { n as RoleSpec, r as RoleValueShape } from "./role-manifest-8OERX9-s.mjs";
+/** Cordis row name, used by Loader diagnostics. */
+export declare const name = "pstack-role-catalog";
+/** The row only needs the tool registry. */
+export declare const inject: string[];
+/** Model-facing tool name. */
+export declare const TOOL_NAME = "pstack_roles";
+/** Whether `roleIndex` may be passed for a role. */
+export type RoleIndexApplicability = "not-applicable" | "optional";
+export interface RoleCapability {
+  /** The exact key to pass as `role`. */
+  readonly role: string;
+  /** One route, or a comma-separated list of routes. */
+  readonly shape: RoleValueShape;
+  /** A list role that starts one child per entry automatically. */
+  readonly autoPanel: boolean;
+  /** `optional` only for a list role that is not an automatic panel. */
+  readonly roleIndex: RoleIndexApplicability;
+  /** How this role expands into children. */
+  readonly usage: string;
+}
+/** Derive one role's capability from its manifest entry. */
+export declare function roleCapability(spec: RoleSpec): RoleCapability;
+/** Every role's capability, in manifest order. */
+export declare function roleCapabilities(): readonly RoleCapability[];
+/** Render the capability list for the model. */
+export declare function renderRoleCapabilities(roles: readonly RoleCapability[]): string;
+export declare function createPstackRoleCatalogTool(): ToolDefinition;
+/** The slice of the Cordis context this row uses. */
+export interface PstackRoleCatalogHost {
+  readonly tools: ToolsHost;
+}
+/** Register `pstack_roles`. */
+export declare function apply(ctx: PstackRoleCatalogHost): void;

package/dist/role-catalog.mjs

@@ -0,0 +1,122 @@
+import { r as ROLE_MANIFEST } from "./role-manifest-79cnFfDM.mjs";
+// src/role-catalog.ts
+/** Cordis row name, used by Loader diagnostics. */
+const name = "pstack-role-catalog";
+/** The row only needs the tool registry. */
+const inject = ["tools"];
+/** Model-facing tool name. */
+const TOOL_NAME = "pstack_roles";
+/** Derive one role's capability from its manifest entry. */
+function roleCapability(spec) {
+	if (spec.autoPanel) return {
+		role: spec.key,
+		shape: spec.shape,
+		autoPanel: true,
+		roleIndex: "not-applicable",
+		usage: "one child per configured entry"
+	};
+	if (spec.shape === "list") return {
+		role: spec.key,
+		shape: spec.shape,
+		autoPanel: false,
+		roleIndex: "optional",
+		usage: "one child, choosing one configured entry"
+	};
+	return {
+		role: spec.key,
+		shape: spec.shape,
+		autoPanel: false,
+		roleIndex: "not-applicable",
+		usage: "one child on the role's single route"
+	};
+}
+/** Every role's capability, in manifest order. */
+function roleCapabilities() {
+	return ROLE_MANIFEST.map(roleCapability);
+}
+/** Render the capability list for the model. */
+function renderRoleCapabilities(roles) {
+	return [
+		"pstack roles. Pass the exact `role` key. `roleIndex` is null unless the role is a list that is not an automatic panel.",
+		"",
+		...roles.map((role) => `- ${role.role} — shape=${role.shape}${role.autoPanel ? ", autoPanel=true" : ""}; roleIndex=${role.roleIndex}; ${role.usage}`)
+	].join("\n");
+}
+const OUTPUT_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	properties: { roles: {
+		type: "array",
+		description: "One capability record per role, in manifest order.",
+		items: {
+			type: "object",
+			additionalProperties: false,
+			properties: {
+				role: {
+					type: "string",
+					description: "The exact key to pass as `role`."
+				},
+				shape: {
+					type: "string",
+					enum: ["single", "list"],
+					description: "One route, or a comma-separated list of routes."
+				},
+				autoPanel: {
+					type: "boolean",
+					description: "A list role that starts one child per configured entry."
+				},
+				roleIndex: {
+					type: "string",
+					enum: ["not-applicable", "optional"],
+					description: "`optional` only for a list role that is not an automatic panel; otherwise pass null."
+				},
+				usage: {
+					type: "string",
+					description: "How this role expands into children."
+				}
+			},
+			required: [
+				"role",
+				"shape",
+				"autoPanel",
+				"roleIndex",
+				"usage"
+			]
+		}
+	} },
+	required: ["roles"]
+};
+const TOOL_DESCRIPTION = [
+	"List every pstack role with its `shape` and `autoPanel`, so a `pstack_subagent` call passes the right `role` and `roleIndex` before it starts.",
+	"",
+	"Read-only. It reports the role manifest, not the routes in `$DSH_HOME/pstack-models.mdc`; use `pstack_models` for the routes this deployment actually serves.",
+	"",
+	"`roleIndex` applies only to a list role that is not an automatic panel: `arena cross-judge pool` and `swarm workers`. Pass `null` for every single role and for an automatic panel (`arena runners`, `architect runners`, `interrogate reviewers`), which starts one child per configured entry."
+].join("\n");
+function createPstackRoleCatalogTool() {
+	return {
+		name: TOOL_NAME,
+		description: TOOL_DESCRIPTION,
+		parameters: {
+			type: "object",
+			additionalProperties: false,
+			properties: {}
+		},
+		output: {
+			schema: OUTPUT_SCHEMA,
+			render: (_args, value) => [{
+				type: "text",
+				text: renderRoleCapabilities(value.roles)
+			}]
+		},
+		isConcurrencySafe: () => true,
+		async execute() {
+			return { roles: roleCapabilities() };
+		}
+	};
+}
+/** Register `pstack_roles`. */
+function apply(ctx) {
+	ctx.tools.register(createPstackRoleCatalogTool());
+}
+export { TOOL_NAME, apply, createPstackRoleCatalogTool, inject, name, renderRoleCapabilities, roleCapabilities, roleCapability };