@taiga-ai/mcp-server 0.16.0-dev.430 → 0.16.0-dev.433

package/dist/index.js

@@ -578,6 +578,42 @@ const pagination = {
 const slug = z.string().max(63).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "A slug is lowercase words joined by hyphens").describe("Product slug, as it appears in Taiga URLs");
 const remoteUrl = z.string().min(1).max(2048).describe("The git remote URL of a checkout (git remote get-url origin): https://, git@host:owner/repo.git or ssh://");
 //#endregion
+//#region ../../packages/types/dist/lenient-schema.js
+/**
+* Building blocks for reading JSON that arrives untyped -- a stored jsonb
+* column, an agent's answer, a document body -- as a parsed type rather than
+* a `Record<string, unknown>` narrowed field by field (PRO-2514).
+*
+* They encode the two leniencies a hand-written reader already had, so a
+* schema built from them accepts, drops and defaults exactly what the reader
+* it replaces did:
+*
+* - `lenient`: a field read only when it has the expected type, and otherwise
+*   treated as absent. Never wrap a schema whose failure must surface: the
+*   catch would swallow it and read a malformed value as "absent".
+* - `lenientList`: a list read item by item, where an item that does not parse
+*   is skipped and the rest survive.
+*/
+/** A field read only when it has the expected type; anything else reads as absent. */
+function lenient(schema) {
+	return schema.optional().catch(void 0);
+}
+/**
+* The item schema of every `lenientList`, which its transform otherwise hides:
+* read by the agent contract test, which walks each schema's keys to hold the
+* shared fixtures to them.
+*/
+const lenientListItems = /* @__PURE__ */ new WeakMap();
+/** A list read item by item: an item that does not parse is skipped, as the reader's `continue` did. */
+function lenientList(item) {
+	const list = z.array(z.unknown()).transform((items) => items.flatMap((entry) => {
+		const parsed = item.safeParse(entry);
+		return parsed.success ? [parsed.data] : [];
+	}));
+	lenientListItems.set(list, item);
+	return list;
+}
+//#endregion
 //#region ../../packages/types/dist/tenants.js
 const TENANT_DOCUMENT_TYPES = [
 	"policy_security",
@@ -1221,6 +1257,57 @@ const BUILD_RUN_ACTIVE_STATUSES = BUILD_RUN_STATUSES.filter((s) => runDispositio
 * DIFFERENT, narrower concept: transitions a user command may never leave.
 */
 const BUILD_RUN_TERMINAL_STATUSES = BUILD_RUN_STATUSES.filter((s) => runDisposition(s) !== "in_flight");
+/**
+* Why the agent kept a pull request a draft, as recorded in its description
+* (PRO-2298). The API reads these markers; the run's escalation carries them.
+*/
+const READY_BLOCKERS = [
+	"plan_incomplete",
+	"tests_failed",
+	"bar_lowering",
+	"bar_lowering_unchecked",
+	"criticals_unresolved"
+];
+/**
+* Why the autonomous loop handed a live pull request to a person (PRO-2409).
+* One per path that sets `reviewEscalated`:
+* - `ci_fix_cap`: CI kept failing after the automatic fix rounds ran out;
+* - `ci_fix_stalled`: a fix round on the failing head pushed nothing;
+* - `conflict_cap`: the branch still conflicts with its base at the cap;
+* - `ready_blocked`: CI is green, but the description says why it is a draft;
+* - `check_weakened`: CI went green only after a fix loosened a check;
+* - `review_bot_cap`: a review BOT (Copilot, CodeRabbit) kept reviewing after
+*   the automatic rounds ran out (PRO-2480). A bot's review never resets the
+*   streak a person's does, so the agent and the bot cannot loop without end.
+*/
+const REVIEW_ESCALATION_REASONS = [
+	"ci_fix_cap",
+	"ci_fix_stalled",
+	"conflict_cap",
+	"ready_blocked",
+	"check_weakened",
+	"review_bot_cap"
+];
+/** One failing check as stored: the name is required, and the link survives only as http(s). */
+const storedFailingCheck = z.object({
+	name: z.string(),
+	url: z.string().regex(/^https?:\/\//i).nullable().catch(null)
+});
+z.object({
+	reason: z.enum(REVIEW_ESCALATION_REASONS),
+	rounds: lenient(z.number().refine((n) => Number.isInteger(n) && n >= 0)),
+	headSha: lenient(z.string()),
+	file: lenient(z.string()),
+	failingChecks: lenient(lenientList(storedFailingCheck)),
+	blockers: lenient(lenientList(z.enum(READY_BLOCKERS)))
+}).transform((e) => ({
+	reason: e.reason,
+	...e.rounds === void 0 ? {} : { rounds: e.rounds },
+	...e.headSha === void 0 ? {} : { headSha: e.headSha },
+	...e.file === void 0 ? {} : { file: e.file },
+	...e.failingChecks === void 0 ? {} : { failingChecks: e.failingChecks },
+	...e.blockers === void 0 ? {} : { blockers: e.blockers }
+}));
 [...BUILD_RUN_ACTIVE_STATUSES.filter((s) => s !== "reviewing")];
 //#endregion
 //#region ../../packages/types/dist/agents.js
@@ -1241,26 +1328,30 @@ const BACKLOG_GENERATION_EMPTY_OUTCOMES = [
 	"out_of_scope",
 	"needs_decision"
 ];
-function isRecord$1(value) {
-	return typeof value === "object" && value !== null;
-}
-function isStringOrNull(value) {
-	return value === null || typeof value === "string";
-}
-function isDecisionReason(value) {
-	if (!isRecord$1(value)) return false;
-	const { policyCode, quotedSpan, conflict, alternative, overridePath } = value;
-	return [
-		policyCode,
-		quotedSpan,
-		conflict,
-		alternative,
-		overridePath
-	].every((f) => typeof f === "string");
-}
-function isCoveringInitiative(value) {
-	return isRecord$1(value) && typeof value.id === "string" && value.id.length > 0 && typeof value.title === "string" && typeof value.priority === "number";
-}
+const decisionReason = z.object({
+	policyCode: z.string(),
+	quotedSpan: z.string(),
+	conflict: z.string(),
+	alternative: z.string(),
+	overridePath: z.string()
+});
+const coveringInitiative = z.object({
+	id: z.string().min(1),
+	title: z.string(),
+	priority: z.number()
+});
+/**
+* The empty verdict, every field checked: the reader navigates on
+* `coveredInitiative.id` and renders `message`.
+*/
+const backlogGenerationEmptyResult = z.object({
+	outcome: z.enum(BACKLOG_GENERATION_EMPTY_OUTCOMES),
+	message: z.string().nullable(),
+	coveredByPriority: z.number().refine(Number.isInteger).nullable(),
+	coveredById: z.string().nullable(),
+	coveredInitiative: coveringInitiative.nullable(),
+	reason: decisionReason.nullable().optional()
+});
 /**
 * Narrow an `agent_jobs.result` blob to {@link BacklogGenerationEmptyResult}.
 *
@@ -1270,10 +1361,9 @@ function isCoveringInitiative(value) {
 * would hand the page an undefined id to navigate to.
 */
 function isBacklogGenerationEmptyResult(value) {
-	if (!isRecord$1(value)) return false;
-	const { outcome, message, coveredByPriority, coveredById, coveredInitiative, reason } = value;
-	return typeof outcome === "string" && BACKLOG_GENERATION_EMPTY_OUTCOMES.includes(outcome) && isStringOrNull(message) && (coveredByPriority === null || typeof coveredByPriority === "number" && Number.isInteger(coveredByPriority)) && isStringOrNull(coveredById) && (coveredInitiative === null || isCoveringInitiative(coveredInitiative)) && (reason === null || reason === void 0 || isDecisionReason(reason));
+	return backlogGenerationEmptyResult.safeParse(value).success;
 }
+const withCreatedInitiativeIds = z.object({ createdInitiativeIds: z.array(z.string().min(1)) });
 /**
 * The initiatives a `generate_backlog` job created, from its stored result
 * (PRO-2483), or null when the result does not say: a job finished before the
@@ -1282,11 +1372,13 @@ function isBacklogGenerationEmptyResult(value) {
 * the reader navigates on them.
 */
 function createdInitiativeIdsOf(result) {
-	if (!isRecord$1(result)) return null;
-	const ids = result.createdInitiativeIds;
-	if (!Array.isArray(ids) || !ids.every((id) => typeof id === "string" && id.length > 0)) return null;
-	return ids;
+	const parsed = withCreatedInitiativeIds.safeParse(result);
+	return parsed.success ? parsed.data.createdInitiativeIds : null;
 }
+const withCreatedInitiatives = z.object({ createdInitiatives: z.array(z.object({
+	id: z.string().min(1),
+	title: z.string()
+})).min(1) });
 /**
 * The initiatives a `generate_backlog` run added, each with the title it was
 * created with, as the worker writes them on `agent_jobs.result.createdInitiatives`
@@ -1299,13 +1391,8 @@ function createdInitiativeIdsOf(result) {
 * read, so a reader never links an undefined id.
 */
 function createdInitiativesOf(result) {
-	if (!isRecord$1(result)) return null;
-	const list = result.createdInitiatives;
-	if (!Array.isArray(list) || list.length === 0) return null;
-	return list.every((entry) => isRecord$1(entry) && typeof entry.id === "string" && entry.id.length > 0 && typeof entry.title === "string") ? list.map((entry) => ({
-		id: entry.id,
-		title: entry.title
-	})) : null;
+	const parsed = withCreatedInitiatives.safeParse(result);
+	return parsed.success ? parsed.data.createdInitiatives : null;
 }
 //#endregion
 //#region ../../packages/types/dist/environments.js
@@ -1322,6 +1409,14 @@ const ENVIRONMENT_TYPES = [
 //#endregion
 //#region ../../packages/types/dist/maintenance.js
 /**
+* Maintenance taxonomy + API DTOs.
+*
+* Single source of truth shared by the `maintenance_*` DB schema, the
+* maintenance API, the maintenance batch agent's output contract, and the
+* Maintaining page. Maintenance is the operational-hygiene system of record,
+* deliberately SEPARATE from the product backlog.
+*/
+/**
 * - vulnerable_dependency / outdated_dependency: the dependency scanner
 * - secret:        the secrets scanner -- a credential committed to the repository
 * - sast:          the SAST scanner over Taiga-authored rules -- an insecure code pattern
@@ -1406,6 +1501,34 @@ const MAINTENANCE_IGNORE_REASONS = [
 	"wont_fix"
 ];
 new Set(CODE_REMEDIATION_KINDS);
+/** A non-empty string, or null. */
+const locationText = z.string().min(1).nullable().catch(null);
+/**
+* A source line is a positive integer or nothing: the response schema declares
+* `int()`, so a fractional value here would fail serialization for the WHOLE
+* list rather than blank one row; and 0 is "no position" for scanners that
+* report [0, 0] for a check with no concrete line.
+*/
+const sourceLine = z.number().refine((n) => Number.isInteger(n) && n > 0).nullable().catch(null);
+z.object({
+	rule_id: locationText,
+	rule_url: locationText,
+	tool: locationText,
+	line: sourceLine,
+	end_line: sourceLine,
+	resource: locationText,
+	in_tree: z.unknown().optional(),
+	commit: z.string().regex(/^[0-9a-f]{7,40}$/).nullable().catch(null)
+}).transform((d) => ({
+	ruleId: d.rule_id,
+	ruleUrl: d.rule_url,
+	tool: d.tool,
+	line: d.line,
+	endLine: d.end_line,
+	resource: d.resource,
+	historyOnly: d.in_tree === false,
+	commit: d.commit
+}));
 //#endregion
 //#region ../../packages/types/dist/design-tokens.js
 /**
@@ -1557,6 +1680,31 @@ const ARTIFACT_SCALE_FRAME_NAMES = [
 [...ARTIFACT_CSS_VARIABLES, ...ARTIFACT_SCALE_FRAME_NAMES];
 new Set(ARTIFACT_CSS_VARIABLES.filter((name) => name !== "--radius"));
 //#endregion
+//#region ../../packages/types/dist/design-emitter.js
+/**
+* Design-system emitter (PRO-887): materialise the tenant's INTERNAL Design
+* Standards document into real files for a generated application.
+*
+* Until this existed the internal path reached code only as plan prose: the
+* planner named tokens, INSPECT flagged literal colours, but nothing wrote a
+* token file, so the coder hedged every colour as `var(--x, #hex)`. A linked
+* design system ships its own package and never needs this -- the dispatcher
+* gates the emitter off whenever one is linked (single source of truth).
+*
+* Pure and deterministic: same document, same bytes. No DOM, no React, no
+* I/O -- the API computes the files, the coding agent writes them.
+*/
+const tokenObject = z.record(z.string(), z.unknown());
+z.object({
+	tokenConvention: lenient(z.string()),
+	tokens: lenient(tokenObject),
+	components: lenient(tokenObject)
+});
+z.object({
+	fontFamily: lenient(z.union([z.string(), z.number()])),
+	fontSize: lenient(z.union([z.string(), z.number()]))
+});
+//#endregion
 //#region ../../packages/types/dist/auto-build.js
 /**
 * Auto-build: the review-plans gate (PRO-1305).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ai/mcp-server",
-  "version": "0.16.0-dev.430",
+  "version": "0.16.0-dev.433",
   "description": "MCP server for Taiga -- gives AI assistants access to documents and products",
   "type": "module",
   "main": "./dist/index.js",

package/scripts/prepare-publish.cjs

@@ -5,9 +5,10 @@
  *
  * - Removes `private: true` so npm allows publishing
  * - Sets publishConfig to public access
- * - Strips workspace-only dependencies. `@taiga/types` is compile-time only
- *   (erased); `@taiga/feature-flags` is a runtime value but is bundled into
- *   dist/index.js by the rolldown build, so neither is a real runtime dep.
+ * - Strips workspace-only dependencies. `@taiga/types` and
+ *   `@taiga/feature-flags` carry runtime code, but the rolldown build bundles
+ *   both into dist/index.js, so neither is a real runtime dep. The `zod` that
+ *   `@taiga/types` imports stays external: it is a declared dependency.
  * - Drops the `types` entry points — the published artifact is a bundled CLI
  *   and ships no `.d.ts` (the build runs `tsc --noEmit`).
  * - Marks the bin entry executable. The bundler emits dist/index.js with mode