@zhangj1164/dsh-github-issue 0.0.0-stage → 0.1.0

package/lib/index.js

@@ -0,0 +1,627 @@
+import s from "@deepseek-ai/schemastery";
+import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { EMPTY_RESPONSE_CODE, createUserMessage } from "@deepseek-ai/dsh-llm";
+//#region src/llm-text.ts
+/**
+* Model-text helper for this service: ask a model for one block of text and
+* keep the reason when there is none.
+*
+* The DSH LLM runtime normalizes every adapter, credential, routing, and
+* transport failure into a terminal `finish` chunk carrying an
+* {@link LlmFailure}. Collapsing that into a bare `undefined` destroys the
+* only actionable facts — the machine-routing `code` (`NO_ADAPTER`,
+* `MISSING_CREDENTIAL`, `AUTH`, `RATE_LIMIT`, …), the provider-neutral
+* message, and the HTTP status — and makes a misconfigured provider route
+* indistinguishable from a model that legitimately returned nothing. This
+* service did exactly that, and reported every one of those conditions as
+* "the model produced no output".
+*
+* This is the same helper `dsh-memo` uses, kept structurally identical
+* (`packages/memo/dsh-memo/src/llm-text.ts`) so the two services report a
+* failure the same way. It is duplicated rather than shared because
+* `dsh-github-issue` is the lower layer — `dsh-memo` depends on it, not the
+* other way round — and a third consumer is the point at which the pair is
+* worth extracting.
+*
+* @module @zhangj1164/dsh-github-issue/llm-text
+*/
+/**
+* Stream one model call and collect its text output.
+*
+* @param llm - the DSH `llm` service, or `undefined` when it is not mounted.
+* @param route - the provider and model to call.
+* @param system - system prompt text.
+* @param userText - user message text.
+* @returns the collected text, or the preserved terminal-failure facts.
+*/
+async function streamLlmText(llm, route, system, userText) {
+	if (llm === void 0) return {
+		ok: false,
+		failure: {
+			code: "LLM_UNAVAILABLE",
+			message: "the llm service is not mounted"
+		}
+	};
+	if (route.provider.length === 0 || route.model.length === 0) return {
+		ok: false,
+		failure: {
+			code: "NO_MODEL_ROUTE",
+			message: "no model route is configured; set the provider and model on this service or on agent-default-model"
+		}
+	};
+	const message = createUserMessage({
+		content: [{
+			type: "text",
+			text: userText
+		}],
+		source: { kind: "user" }
+	});
+	const options = {
+		provider: route.provider,
+		model: route.model,
+		messages: [message],
+		system
+	};
+	let text = "";
+	try {
+		for await (const chunk of llm.stream(options)) if (chunk.type === "text-delta") text += chunk.text;
+		else if (chunk.type === "finish" && (chunk.reason.kind === "error" || chunk.reason.kind === "aborted")) {
+			const failure = chunk.reason.failure;
+			return {
+				ok: false,
+				failure: {
+					code: failure.code,
+					message: failure.message,
+					...failure.status === void 0 ? {} : { status: failure.status }
+				}
+			};
+		}
+	} catch (error) {
+		return {
+			ok: false,
+			failure: {
+				code: "LLM_STREAM_THREW",
+				message: error instanceof Error ? error.message : String(error)
+			}
+		};
+	}
+	if (text.length === 0) return {
+		ok: false,
+		failure: {
+			code: EMPTY_RESPONSE_CODE,
+			message: "the model returned no text for this request"
+		}
+	};
+	return {
+		ok: true,
+		text
+	};
+}
+//#endregion
+//#region src/index.ts
+/**
+* GitHub-issue generation service: builds uniform GitHub issue reports from
+* telemetry analysis, constructs pre-filled issue-creation URLs, and optimizes
+* natural-language issue descriptions with the configured model.
+*
+* Extends `TypertRemoteService` because the client issue-editor UI calls
+* `optimizeIssue` and `prefilledIssueUrl` directly, and the memo log-analysis
+* flow calls `generateReport`.
+*
+* @module @zhangj1164/dsh-github-issue
+*/
+var __runInitializers = function(thisArg, initializers, value) {
+	var useValue = arguments.length > 2;
+	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+	return useValue ? value : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+	function accept(f) {
+		if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+		return f;
+	}
+	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+	var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+	var _, done = false;
+	for (var i = decorators.length - 1; i >= 0; i--) {
+		var context = {};
+		for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+		for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+		context.addInitializer = function(f) {
+			if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+			extraInitializers.push(accept(f || null));
+		};
+		var result = (0, decorators[i])(kind === "accessor" ? {
+			get: descriptor.get,
+			set: descriptor.set
+		} : descriptor[key], context);
+		if (kind === "accessor") {
+			if (result === void 0) continue;
+			if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+			if (_ = accept(result.get)) descriptor.get = _;
+			if (_ = accept(result.set)) descriptor.set = _;
+			if (_ = accept(result.init)) initializers.unshift(_);
+		} else if (_ = accept(result)) {
+			if (kind === "field") initializers.unshift(_);
+			else descriptor[key] = _;
+		}
+	}
+	if (target) Object.defineProperty(target, contextIn.name, descriptor);
+	done = true;
+};
+/** Schemastery configuration for the GitHub-issue service. */
+const Config = s.object({
+	repoUrl: s.string().default("https://github.com/zhangj1164/dsh-mega-plugins"),
+	maxPrefillUrlLength: s.number().default(7e3),
+	prefillTruncationNote: s.string().default("\n\n> （正文过长，已截断以适配 GitHub 的 URL 长度限制。完整正文见备忘面板的「复制完整正文」。）"),
+	provider: s.string(),
+	model: s.string()
+});
+/** The built-in system prompt that structures a natural-language issue description. */
+const OPTIMIZE_SYSTEM_PROMPT = [
+	"You are a technical issue reporter. Rewrite the user's description into a",
+	"well-structured GitHub issue following this exact Markdown template.",
+	"Fill every section from the description; if a section has no information,",
+	"state \"No information provided.\" Do not add information the user did not give.",
+	"",
+	"The title (first line) must contain Chinese characters.",
+	"The visible body must be under 50 units of text; place all detail inside a",
+	"default-collapsed <details> block so the issue body stays compact.",
+	"",
+	"Template:",
+	"## <brief Chinese title>",
+	"",
+	"<details>",
+	"<summary>复现、预期与验收</summary>",
+	"",
+	"- 插件 / Plugin:",
+	"- 操作 / Action:",
+	"- 预期行为 / Expected:",
+	"- 实际行为 / Actual:",
+	"- 复现步骤 / Steps to Reproduce:",
+	"- 环境 / Environment:",
+	"",
+	"</details>",
+	"",
+	"Return only the Markdown body (no code fences around the whole output).",
+	"The first line must be a concise title prefixed with \"## \"."
+].join("\n");
+/** How a fact the analysis did not carry is written, so it reads as absent data. */
+const NOT_RECORDED = "not recorded";
+/**
+* The failure returned when a request arrives without a model route.
+*
+* Named rather than folded into `llm-failure`: a missing route and a model that
+* truly produced nothing are different defects with different owners. Reporting
+* the first as the second sent a user hunting for a model problem in a request
+* that never reached a model.
+*/
+const ROUTE_MISSING = {
+	ok: false,
+	error: {
+		code: "route-missing",
+		message: "no model route was supplied for this call; the caller must pass the provider and model to use"
+	}
+};
+/** The plugin id these events are recorded under, alongside `memo`. */
+const TELEMETRY_PLUGIN_ID = "github-issue";
+/** The DSH machine-routing code `dsh-memo` also uses when nothing resolves a route. */
+const NO_MODEL_ROUTE_CODE = "NO_MODEL_ROUTE";
+/** The built-in system prompt that generates a report from telemetry analysis. */
+const REPORT_SYSTEM_PROMPT = [
+	"You are a diagnostic report generator. Given a plugin's telemetry failure",
+	"analysis, produce a GitHub issue report that correlates each failure group",
+	"against the plugin's feature code. For each group, state the feature-code",
+	"anchor, the error code and message, the route and timing the analysis gives,",
+	"a likely cause, and a suggested fix.",
+	"",
+	"Ground every statement in the analysis you were given:",
+	"- Cite only facts present in it. Never propose a mechanism the analysis does",
+	"  not evidence — do not mention sampling parameters, token budgets,",
+	"  timeouts, chunking, streaming, or response parsing unless the analysis",
+	"  names that mechanism.",
+	"- Report the analysis window, and per failure group the route, the last",
+	"  failure time, and how many attempts of the same action followed it. Say how",
+	"  old the last failure is and whether the action ran again afterwards; a",
+	"  failure that has not recurred is not a current defect.",
+	`- Write "${NOT_RECORDED}" for a fact the analysis does not carry. Never write`,
+	"  that collection needs to be added: a missing fact can be an older event as",
+	"  easily as a gap, and the report cannot tell which.",
+	"",
+	"The title (first line) must contain Chinese characters.",
+	"Place all detail inside a default-collapsed <details> block.",
+	"",
+	"Template:",
+	"## <brief Chinese title>",
+	"",
+	"<details>",
+	"<summary>诊断报告</summary>",
+	"",
+	"### 插件 / Plugin",
+	"### 操作 / Action",
+	"### 预期行为 / Expected",
+	"### 实际行为 / Actual",
+	"### 路由与时间 / Route and Timing",
+	"### 可能原因 / Possible Cause",
+	"### 错误日志 / Error Logs",
+	"### 环境 / Environment",
+	"",
+	"</details>",
+	"",
+	"Return only the Markdown body. The first line must be a concise Chinese title."
+].join("\n");
+/**
+* GitHub-issue generation and optimization service over the configured model.
+*/
+let GithubIssueService = (() => {
+	let _classSuper = TypertRemoteService;
+	let _instanceExtraInitializers = [];
+	let _generateReport_decorators;
+	let _prefilledIssueUrl_decorators;
+	let _optimizeIssue_decorators;
+	return class GithubIssueService extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_generateReport_decorators = [Remote("generateReport")];
+			_prefilledIssueUrl_decorators = [Remote("prefilledIssueUrl")];
+			_optimizeIssue_decorators = [Remote("optimizeIssue")];
+			__esDecorate(this, null, _generateReport_decorators, {
+				kind: "method",
+				name: "generateReport",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "generateReport" in obj,
+					get: (obj) => obj.generateReport
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _prefilledIssueUrl_decorators, {
+				kind: "method",
+				name: "prefilledIssueUrl",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "prefilledIssueUrl" in obj,
+					get: (obj) => obj.prefilledIssueUrl
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _optimizeIssue_decorators, {
+				kind: "method",
+				name: "optimizeIssue",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "optimizeIssue" in obj,
+					get: (obj) => obj.optimizeIssue
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static inject = ["llm"];
+		static Config = Config;
+		repoUrl = __runInitializers(this, _instanceExtraInitializers);
+		maxPrefillUrlLength;
+		prefillTruncationNote;
+		/** Configured provider route, or `undefined` to follow `agentDefaultModel`. */
+		provider;
+		/** Configured model id, or `undefined` to follow `agentDefaultModel`. */
+		model;
+		/**
+		* @param ctx - Host context carrying the llm service.
+		* @param config - Validated deployment configuration.
+		*/
+		constructor(ctx, config) {
+			super(ctx, "githubIssue");
+			this.repoUrl = config.repoUrl;
+			this.maxPrefillUrlLength = config.maxPrefillUrlLength;
+			this.prefillTruncationNote = config.prefillTruncationNote;
+			this.provider = config.provider;
+			this.model = config.model;
+		}
+		/**
+		* Resolve the model route for one model call.
+		*
+		* The caller's explicit request wins, then this service's validated `Config`,
+		* then the deployment's `agentDefaultModel` selection — the same order the
+		* memo service uses, so one deployment-level answer decides both. A blank
+		* half is treated as absent rather than as a value: it is the shape an
+		* omitted field arrives in, and letting it win would send a call with no
+		* adapter, whose failure ("the model produced no output") blames the model
+		* for a routing problem.
+		*
+		* @param request - the caller's optional route.
+		* @returns the resolved route, or `undefined` when nothing resolved one.
+		*/
+		resolveRoute(request) {
+			const selection = this.ctx.get("agentDefaultModel")?.currentSelection();
+			const provider = firstNonBlank(request.provider, this.provider, selection?.provider);
+			const model = firstNonBlank(request.model, this.model, selection?.model);
+			if (provider === void 0 || model === void 0) return void 0;
+			return {
+				provider,
+				model
+			};
+		}
+		/**
+		* Generate a uniform GitHub issue report from a telemetry failure analysis.
+		* Calls the configured model with a built-in structuring prompt.
+		* @param request - the analysis input from the telemetry service.
+		* @returns the generated report or an LLM failure.
+		*/
+		async generateReport(request) {
+			const route = this.resolveRoute(request);
+			if (route === void 0) return this.routeMissing("generateReport");
+			const userPrompt = buildReportUserPrompt(request);
+			const result = await streamLlmText(this.ctx.get("llm"), route, REPORT_SYSTEM_PROMPT, userPrompt);
+			if (!result.ok) return this.llmFailure("generateReport", route, result);
+			const title = extractTitle(result.text) ?? `Telemetry failures in ${request.pluginIds.join(", ")}`;
+			this.track("generateReport", "success", {
+				pluginIds: [...request.pluginIds],
+				...this.routeFacts(route)
+			});
+			return {
+				ok: true,
+				value: Object.freeze({
+					title,
+					body: result.text,
+					labels: Object.freeze(["bug", "telemetry"])
+				})
+			};
+		}
+		/**
+		* Build a pre-filled GitHub issue-creation URL from a report.
+		*
+		* The body is shortened when the finished URL would exceed the configured
+		* limit. The check is on the URL rather than on the body alone because the
+		* title and labels spend the same budget and percent-encoding inflates it,
+		* so a body-length rule would still produce a URL GitHub refuses.
+		*
+		* @param request - the repository URL and the report to prefill.
+		* @returns the prefill URL or an invalid-URL failure.
+		*/
+		prefilledIssueUrl(request) {
+			const repoUrl = request.repoUrl.length > 0 ? request.repoUrl : this.repoUrl;
+			if (!/^https:\/\/github\.com\/[^/]+\/[^/]+$/u.test(repoUrl)) return {
+				ok: false,
+				error: {
+					code: "invalid-url",
+					message: `repoUrl "${repoUrl}" is not a valid GitHub repository URL`
+				}
+			};
+			return {
+				ok: true,
+				value: buildPrefillUrl(repoUrl, request.report, this.maxPrefillUrlLength, this.prefillTruncationNote)
+			};
+		}
+		/**
+		* Optimize a natural-language issue description into a structured report
+		* using the configured model and a built-in structuring prompt.
+		* @param request - the raw description and model route.
+		* @returns the structured report or an LLM failure.
+		*/
+		async optimizeIssue(request) {
+			if (request.description.trim().length === 0) return {
+				ok: false,
+				error: {
+					code: "empty-input",
+					message: "the issue description is empty"
+				}
+			};
+			const route = this.resolveRoute(request);
+			if (route === void 0) return this.routeMissing("optimizeIssue");
+			const result = await streamLlmText(this.ctx.get("llm"), route, OPTIMIZE_SYSTEM_PROMPT, request.description);
+			if (!result.ok) return this.llmFailure("optimizeIssue", route, result);
+			const title = extractTitle(result.text) ?? "New issue";
+			this.track("optimizeIssue", "success", this.routeFacts(route));
+			return {
+				ok: true,
+				value: Object.freeze({
+					title,
+					body: result.text,
+					labels: Object.freeze(["bug"])
+				})
+			};
+		}
+		/**
+		* Report one model failure and return the business failure.
+		*
+		* The preserved DSH code goes into both the message and the telemetry event:
+		* the message is what a user reads, and the event is what a later analysis
+		* groups on. Reporting either as a bare "the model produced no output" is how
+		* an unroutable provider was mistaken for a model that answered nothing.
+		*
+		* @param action - the method the failure happened in, and its telemetry action.
+		* @param route - the route the call was sent to.
+		* @param failure - the preserved DSH failure facts.
+		* @returns the business failure to return to the caller.
+		*/
+		llmFailure(action, route, failure) {
+			const detail = failure.failure;
+			const message = `model call to provider "${route.provider}" model "${route.model}" failed: ${detail.code}: ${detail.message}`;
+			this.trackError(action, {
+				code: detail.code,
+				message: detail.message,
+				featureCodeRef: `${TELEMETRY_PLUGIN_ID}:${action}`
+			}, {
+				...this.routeFacts(route),
+				...detail.status === void 0 ? {} : { status: detail.status }
+			});
+			return {
+				ok: false,
+				error: {
+					code: "llm-failure",
+					message
+				}
+			};
+		}
+		/**
+		* Report a call that arrived with no resolvable route.
+		*
+		* Recorded as a failure rather than silently skipped: this is the defect that
+		* produced an empty model response from every click of the issue editor's
+		* optimize button, and it left no trace anywhere, so it was found by a user
+		* report instead of by the telemetry it should have written.
+		*
+		* @param action - the method the call was made to, and its telemetry action.
+		* @returns the business failure to return to the caller.
+		*/
+		routeMissing(action) {
+			this.trackError(action, {
+				code: NO_MODEL_ROUTE_CODE,
+				message: ROUTE_MISSING.error.message,
+				featureCodeRef: `${TELEMETRY_PLUGIN_ID}:${action}`
+			}, {});
+			return ROUTE_MISSING;
+		}
+		/**
+		* The route facts every AI-related telemetry event carries.
+		*
+		* Success events carry them for the same reason failures do: a record that
+		* names the route only when it broke cannot say which route served the calls
+		* that worked, so a later analysis cannot tell whether the route changed.
+		*
+		* @param route - the route the call used.
+		* @returns the provider and model to merge into an event's metadata.
+		*/
+		routeFacts(route) {
+			return {
+				provider: route.provider,
+				model: route.model
+			};
+		}
+		/**
+		* Record one completed call, when this deployment has telemetry mounted.
+		*
+		* @param action - the method the call was made to.
+		* @param result - whether it succeeded.
+		* @param metadata - structured context, such as the route.
+		*/
+		track(action, result, metadata) {
+			this.ctx.get("telemetry")?.track({
+				pluginId: TELEMETRY_PLUGIN_ID,
+				action,
+				result,
+				...metadata === void 0 ? {} : { metadata }
+			});
+		}
+		/**
+		* Record one failure, when this deployment has telemetry mounted.
+		*
+		* @param action - the method the failure happened in.
+		* @param error - the failure code, message, and feature anchor.
+		* @param metadata - structured context, such as the attempted route.
+		*/
+		trackError(action, error, metadata) {
+			this.ctx.get("telemetry")?.trackError({
+				pluginId: TELEMETRY_PLUGIN_ID,
+				action,
+				error,
+				...metadata === void 0 ? {} : { metadata }
+			});
+		}
+	};
+})();
+/**
+* The first argument that carries a non-blank value.
+*
+* @param values - candidate values, most specific first.
+* @returns the trimmed value, or `undefined` when all are blank or absent.
+*/
+function firstNonBlank(...values) {
+	for (const value of values) if (typeof value === "string" && value.trim().length > 0) return value.trim();
+}
+/**
+* Build the user-facing prompt from a telemetry analysis, listing every
+* failure group with its feature-code anchor, error code, and message.
+*
+* The facts are stated flatly and dated: a report that receives only totals and
+* error codes can say nothing about whether a failure still happens, and a model
+* asked to explain it will invent mechanisms the plugin does not have. Every
+* line here is one the plugin actually recorded, and a missing fact is labelled
+* as missing rather than omitted, so the model can tell "not recorded" from
+* "nothing to report".
+*
+* @param request - the analysis input.
+* @returns the structured prompt text.
+*/
+function buildReportUserPrompt(request) {
+	const groups = request.failureGroups.map((group) => {
+		const lines = [`- featureCodeRef: ${group.featureCodeRef}`, `  count: ${group.count}`];
+		if (group.errorCode !== void 0) lines.push(`  errorCode: ${group.errorCode}`);
+		if (group.errorMessage !== void 0) lines.push(`  errorMessage: ${group.errorMessage}`);
+		lines.push(`  route: ${group.route === void 0 ? NOT_RECORDED : `${group.route.provider} / ${group.route.model}${group.route.status === void 0 ? "" : ` (status ${group.route.status})`}`}`);
+		lines.push(`  lastFailureAt: ${group.lastFailureAt === void 0 ? NOT_RECORDED : new Date(group.lastFailureAt).toISOString()}`);
+		lines.push(`  attemptsAfterLastFailure: ${group.attemptsAfterLastFailure ?? NOT_RECORDED}`);
+		return lines.join("\n");
+	}).join("\n");
+	const window = request.window === void 0 ? `Analysis window: ${NOT_RECORDED}` : `Analysis window: ${new Date(request.window.firstEventAt).toISOString()} .. ${new Date(request.window.lastEventAt).toISOString()}`;
+	return [
+		`Plugins: ${request.pluginIds.length === 0 ? NOT_RECORDED : request.pluginIds.join(", ")}`,
+		window,
+		`Total events: ${request.totalEvents}`,
+		`Total failures: ${request.totalFailures}`,
+		"",
+		"Failure groups:",
+		groups.length === 0 ? "(none)" : groups
+	].join("\n");
+}
+/**
+* Extract a title from the first Markdown heading of the body, if present.
+* @param body - the Markdown body.
+* @returns the heading text without the `## ` prefix, or `undefined`.
+*/
+function extractTitle(body) {
+	return /^##\s+(.+?)$/mu.exec(body)?.[1]?.trim();
+}
+/**
+* Upper bound on the shortening passes in {@link buildPrefillUrl}. Each pass
+* removes at least the overflow it measured, so a handful of passes converge;
+* the bound exists only so a pathological input cannot spin.
+*/
+const MAX_PREFILL_TRUNCATION_PASSES = 32;
+/**
+* Build the pre-filled new-issue URL, shortening the body so the URL stays
+* within `maxLength`.
+*
+* The budget is checked on the composed URL rather than on the body alone,
+* because the title and labels spend the same budget and percent-encoding
+* inflates whatever they contain; a body-length rule would still emit a URL
+* GitHub refuses. Each pass removes at least the overflow it measured, which
+* can overshoot when characters encode to more than one URL character, and
+* overshooting only shortens the body further.
+*
+* @param repoUrl - the repository URL, already validated by the caller.
+* @param report - the report to prefill.
+* @param maxLength - the longest acceptable URL; `0` or less disables shortening.
+* @param note - appended to the body when shortening was necessary.
+* @returns the pre-filled issue URL.
+*/
+function buildPrefillUrl(repoUrl, report, maxLength, note) {
+	const compose = (body) => {
+		const params = new URLSearchParams();
+		params.set("title", report.title);
+		params.set("body", body);
+		if (report.labels.length > 0) params.set("labels", report.labels.join(","));
+		return `${repoUrl}/issues/new?${params.toString()}`;
+	};
+	const full = compose(report.body);
+	if (maxLength <= 0 || full.length <= maxLength) return full;
+	let keep = report.body.length;
+	let candidate = compose(`${report.body.slice(0, keep)}${note}`);
+	for (let pass = 0; pass < MAX_PREFILL_TRUNCATION_PASSES && candidate.length > maxLength && keep > 0; pass += 1) {
+		keep = Math.max(0, keep - Math.max(1, candidate.length - maxLength));
+		candidate = compose(`${report.body.slice(0, keep)}${note}`);
+	}
+	return candidate.length <= maxLength ? candidate : compose(note);
+}
+//#endregion
+export { Config, GithubIssueService, GithubIssueService as default };

package/lib/invariant.d.ts

@@ -0,0 +1,14 @@
+import { Context } from "@deepseek-ai/cordis";
+//#region src/invariant.d.ts
+/** Cordis companion plugin name. */
+declare const name = "github-issue-invariant";
+/** Services required before the companion can reserve and check package ownership. */
+declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+declare const apply: (ctx: Context) => Promise<() => void>;
+//#endregion
+export { apply, inject, name };

package/lib/invariant.js

@@ -0,0 +1,19 @@
+//#region src/invariant.ts
+const PACKAGE_NAME = "@zhangj1164/dsh-github-issue";
+/** Cordis companion plugin name. */
+const name = "github-issue-invariant";
+/** Services required before the companion can reserve and check package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: the service owns its model calls and URL construction
+* deterministically, and no second authority exists.
+*/
+const install = Object.assign(() => {}, { inject: ["githubIssue"] });
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };