@taiga-ai/mcp-server 0.37.0-dev.998 → 0.37.0-dev.999

package/dist/index.js

@@ -24176,6 +24176,107 @@ const CLOUD_PROVIDERS = [
 	"other"
 ];
 //#endregion
+//#region ../../packages/types/dist/ecosystems.js
+/**
+* Engineering ecosystems a tenant builds in.
+*
+* The structural twin of CLOUD_PROVIDERS: a discrete onboarding choice that
+* drives seeded policy content. Clouds say where the software runs; ecosystems
+* say what it is written in.
+*
+* Deliberately scoped to the runtimes the coding agent actually ships skills
+* for (`apps/agents/coding/src/coding/skills/loader.py`, `_RUNTIME_SKILLS`).
+* Offering a choice the agent cannot honour would be worse than not asking.
+* JVM was absent for that reason until the coding image gained the JDK, Maven,
+* Gradle, Ruby and PHP toolchains (PRO-1745) and the agent its `java`,
+* `ruby-rails` and `php-laravel` skills (PRO-2914); see the three entries
+* below.
+*
+* Frontend is its own entry rather than being bundled into `node`, because a
+* stack has tiers and a runtime list cannot express them. React-with-a-Python-
+* backend is one of the most common shapes there is; folding React into `node`
+* would force those tenants to declare a Node backend they do not run, and the
+* seeded policy would then approve Fastify for a Python shop. It also matches
+* the coding agent more closely, which already keeps `node-typescript` and
+* `react-nextjs` as separate skills under one runtime key.
+*
+* `nextjs` is the case that broke the tier model, and the reason it is its own
+* entry rather than react+node (PRO-809). Next.js occupies BOTH tiers: route
+* handlers and Server Actions are a backend, so `react` alone leaves a real
+* backend undeclared, while `react` + `node` approves Fastify and Drizzle at a
+* shop running neither. It also builds with its own bundler, so the react
+* preset's Vite row is wrong for it. One framework spanning two tiers is not
+* something hedged wording can fix; it needs its own entry.
+*
+* `other` is the escape hatch, and exists because its absence was a trap.
+* `CLOUD_PROVIDERS` has always had one; ecosystems did not, so a Vue, Angular
+* or Svelte shop had no true answer: declaring `react` is wrong, and declaring
+* nothing falls to `UNDECLARED_STACK_ROWS`, which opens with
+* "Frontend: React, TypeScript". Both paths asserted React at them. `other`
+* contributes no rows at all, so their approved-technology table is silent
+* about language rather than wrong about it.
+*
+* Note what `other` is NOT: an invitation to add Vue and friends as options.
+* The agent ships no skill for any of them, and the rule above still stands --
+* a skill first, then the option, never the reverse.
+*
+* `angular` is the first entry outside the React family, and it is its own
+* entry for the same reason `nextjs` is: the toolchain, not the language.
+* Angular builds with the Angular CLI's own esbuild-based builder rather than
+* Vite, lints with angular-eslint rather than oxlint, and (since v21) tests
+* with the CLI's Vitest builder rather than a bare Vitest config. Declaring
+* `react` at an Angular shop would seed every one of those rows wrong.
+*
+* It also retires the specific trap `other` was documented with: an Angular
+* shop previously had no true answer. Vue and Svelte still do not, and the
+* rule below is why -- Angular earned the entry by having a coding-agent
+* skill written for it first (PRO-1401), not the reverse.
+*
+* `nestjs` is the backend counterpart of that same rule, and its own entry
+* rather than folding into `node` for the same reason: the toolchain, not the
+* language. `node` approves Fastify, Zod and Drizzle and builds with Vite; a
+* NestJS service runs its own framework on the Express or Fastify adapter,
+* validates with class-validator DTOs, persists through Prisma or TypeORM, and
+* builds with the Nest CLI or Nx. Declaring `node` at a Nest shop would seed
+* every one of those rows wrong. Like Angular, it earned the entry by having
+* its coding-agent skill shipped first (PRO-1901), not the reverse.
+*
+* `react-native` is the mobile client tier, and a separate entry from `react`
+* for the same reason `nextjs` is (PRO-936). `react` is a web SPA that builds
+* with Vite and tests with Vitest/Playwright; React Native is an Expo-managed
+* mobile app that builds with the Expo/EAS toolchain and tests with jest-expo,
+* so declaring `react` would seed a web tenant's Vite/Vitest rows at a mobile
+* shop. Expo-managed is the default and the only variant here: a bare-workflow
+* React Native app is the same source with a different native build pipeline,
+* not a different approved-technology table, so it does not warrant its own id.
+*
+* `java`, `rails` and `laravel` are the server-rendered and API backends
+* outside JavaScript, Python and .NET (PRO-2915). `java` approves Spring Boot as
+* its framework the way `python` approves FastAPI or Django and `go` approves
+* chi: the table names what new work should use, and the picker's sublabel
+* says so ("Spring Boot, Maven or Gradle"). A JVM shop on another framework
+* picks `other` rather than being approved one it does not run. `rails` and
+* `laravel` are named by framework rather than language for the same reason:
+* a Ruby or PHP shop that runs neither has no table we could write for it.
+* Each followed the rule below -- its coding-agent skill shipped first.
+*/
+const ECOSYSTEMS = [
+	"react",
+	"react-native",
+	"angular",
+	"nextjs",
+	"node",
+	"nestjs",
+	"python",
+	"dotnet",
+	"go",
+	"rust",
+	"java",
+	"rails",
+	"laravel",
+	"other"
+];
+//#endregion
 //#region ../../packages/types/dist/lenient-schema.js
 /**
 * Building blocks for reading JSON that arrives untyped -- a stored jsonb
@@ -24334,6 +24435,17 @@ const CONTROL_ID_SOURCE = "[A-Z][A-Z0-9]{1,5}(?:-[A-Z][A-Z0-9]{1,5})*-\\d+(?:\\.
 function isControlId(text) {
 	return new RegExp(`^${CONTROL_ID_SOURCE}$`).test(text);
 }
+const SUPPORTED_INDUSTRIES = [
+	"technology",
+	"telecom",
+	"healthcare",
+	"manufacturing",
+	"defense",
+	"fintech",
+	"public_sector",
+	"energy",
+	"other"
+];
 const EU_COUNTRIES = [
 	{
 		code: "AT",
@@ -24479,8 +24591,28 @@ const UK_COUNTRIES = [{
 ];
 /** Countries available during closed beta. Expand as we open new markets. */
 const BETA_COUNTRIES = ["FI"];
-[...EU_COUNTRIES.map((c) => c.code).filter((code) => !BETA_COUNTRIES.includes(code))];
+/**
+* Countries offered only while the `regulations` flag is on (PRO-3419,
+* PRO-3420): every EU member but Finland, and Norway. Sweden, Denmark and
+* Norway have a national layer of their own; the rest get the EU acts and
+* say, on the Regulations page, that their national law is not in the
+* policies yet (`TenantRegulations.context.countryLayer`). Iceland and
+* Liechtenstein stay unoffered. They go with the flag when it is removed.
+*/
+const PREVIEW_COUNTRIES = [
+	...EU_COUNTRIES.map((c) => c.code).filter((code) => !BETA_COUNTRIES.includes(code)),
+	"NO",
+	"GB"
+];
 EU_COUNTRIES.filter((c) => BETA_COUNTRIES.includes(c.code));
+/**
+* The countries a tenant may choose. The caller passes its own resolution of
+* the `regulations` flag, so the API's validation and the web's picker cannot
+* disagree about which countries exist.
+*/
+function offeredCountries(previewEnabled) {
+	return previewEnabled ? [...BETA_COUNTRIES, ...PREVIEW_COUNTRIES] : [...BETA_COUNTRIES];
+}
 Object.fromEntries([
 	...EU_COUNTRIES.map((c) => [c.code, "eu"]),
 	...EEA_COUNTRIES.map((c) => [c.code, "eea"]),
@@ -27764,6 +27896,66 @@ object({
 });
 /** A value GitHub's redirect carries back: a state token, or a one-time code. */
 const githubCallbackSecret = string$2().trim().min(1).max(1024);
+/** Every country Taiga knows; the server refuses one it does not offer yet. */
+const KNOWN_COUNTRIES = offeredCountries(true);
+const knownCountry = string$2().length(2).refine((code) => KNOWN_COUNTRIES.includes(code), { message: "Unsupported country" });
+strictObject({
+	industries: array(_enum(SUPPORTED_INDUSTRIES)).min(1).optional(),
+	country: knownCountry.optional(),
+	servesEu: boolean().optional(),
+	cloudProviders: array(_enum(CLOUD_PROVIDERS)).min(1).optional(),
+	ecosystems: array(_enum(ECOSYSTEMS)).min(1).optional(),
+	productMarkets: strictObject({
+		productId: uuid,
+		countries: array(knownCountry).max(40)
+	}).optional(),
+	overrides: record(string$2().max(100), array(string$2().max(200)).max(200)).optional()
+}).refine(({ industries, country, servesEu, cloudProviders, ecosystems, productMarkets }) => [
+	industries,
+	country,
+	servesEu,
+	cloudProviders,
+	ecosystems,
+	productMarkets
+].some((x) => x !== void 0), { message: "Provide at least one context field to change" });
+object({
+	context: object({
+		industries: array(string$2()),
+		country: string$2().optional(),
+		operatingRegions: array(string$2()),
+		marketCountries: array(string$2()),
+		cloudProviders: array(_enum(CLOUD_PROVIDERS)),
+		ecosystems: array(_enum(ECOSYSTEMS))
+	}),
+	documents: array(object({
+		type: string$2(),
+		name: string$2(),
+		action: _enum([
+			"seed",
+			"publish",
+			"skip-edited",
+			"backfilled",
+			"up-to-date"
+		]),
+		sections: array(object({
+			key: string$2(),
+			changeType: _enum([
+				"added",
+				"removed",
+				"modified",
+				"reattributed"
+			]),
+			before: string$2().nullable(),
+			after: string$2().nullable(),
+			source: string$2().nullable()
+		})).optional(),
+		conflicts: array(object({
+			key: string$2(),
+			stored: string$2().nullable(),
+			incoming: string$2().nullable()
+		})).optional()
+	}))
+});
 strictObject({
 	displayName: string$2().trim().min(1).max(255),
 	baseUrl: string$2().trim().min(1).max(480),
@@ -27851,7 +28043,7 @@ strictObject({
 }), object({
 	principalArn: string$2().nullable(),
 	externalId: string$2()
-});
+}), object({ documentsMoved: number$1().int() });
 strictObject({ kind: _enum(["sbom", "notices"]) }), object({
 	url: string$2().url().nullable(),
 	expiresAt: string$2().nullable()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ai/mcp-server",
-  "version": "0.37.0-dev.998",
+  "version": "0.37.0-dev.999",
   "description": "Taiga for AI coding assistants: read products, policies, initiatives and runs, and operate the line, over MCP",
   "mcpName": "ga.tai/mcp-server",
   "license": "UNLICENSED",