@taiga-ai/mcp-server 0.18.0-dev.447 → 0.18.0-dev.448

package/src/tools/wait.ts

@@ -1,8 +1,9 @@
 import type { McpServer } from '@modelcontextprotocol/server';
 import { BUILD_RUN_TERMINAL_STATUSES, resolveAutoBuild } from '@taiga/types';
+import type { BacklogItem, BacklogItemLifecycle, BuildRunWithContext } from '@taiga/types';
 import { z } from 'zod';
 import { idInput } from './inputs.js';
-import { TaigaApiError, type TaigaClient } from '../client.js';
+import { TaigaApiError, type TaigaClient, type WithoutTenant } from '../client.js';
 import { READ_ONLY } from './annotations.js';
 import { isNetworkFailure, runTool, toolResult } from './errors.js';
 import { SETTLED_JOB_STATUSES, jobReport } from './jobs.js';
@@ -43,7 +44,11 @@ const timeoutSeconds = z
       'many stop a call at 60 seconds.'
   );
 
-type Row = Record<string, unknown>;
+type Item = WithoutTenant<BacklogItem>;
+type Run = WithoutTenant<BuildRunWithContext>;
+
+/** The pull-request fields an initiative's latest run and a build run both carry. */
+type PullRequestFields = Pick<Run, 'prUrl' | 'prMerged' | 'prState'>;
 
 /** Why a wait ended: the condition held, it can no longer hold on its own, or time ran out. */
 type Verdict = { reached: true } | { reached: false; stoppedBecause: string } | null;
@@ -91,17 +96,17 @@ function isTransient(error: unknown): boolean {
  * it, which also keeps a client that resets its timeout on progress from
  * cutting the wait short.
  */
-async function waitFor(
-  read: (signal: AbortSignal) => Promise<Row>,
-  judge: (now: Row, first: Row) => Verdict,
+async function waitFor<T>(
+  read: (signal: AbortSignal) => Promise<T>,
+  judge: (now: T, first: T) => Verdict,
   timeoutMs: number,
   options: WaitOptions,
   progress: Progress
 ) {
   const started = Date.now();
   const deadline = started + timeoutMs;
-  let first: Row | null = null;
-  let now: Row | null = null;
+  let first: T | null = null;
+  let now: T | null = null;
   let verdict: Verdict = null;
   let failures = 0;
   for (let attempt = 0; !progress.signal.aborted; attempt += 1) {
@@ -156,7 +161,7 @@ const SETTLED_RUN: ReadonlySet<string> = new Set(BUILD_RUN_TERMINAL_STATUSES);
  * is open; the mirrored state and the merged latch say which. An unknown
  * state (null, just opened) counts as open.
  */
-function prIsOpen(run: Row): boolean {
+function prIsOpen(run: PullRequestFields): boolean {
   return typeof run.prUrl === 'string' && run.prUrl !== '' && run.prMerged !== true && run.prState !== 'closed';
 }
 
@@ -167,11 +172,13 @@ function prIsOpen(run: Row): boolean {
 const ITEM_CONDITIONS = ['changed', 'planned', 'your_turn', 'pr_open', 'run_settled', 'done'] as const;
 type ItemCondition = (typeof ITEM_CONDITIONS)[number];
 
-const latestBuildOf = (item: Row) => ((item.lifecycle as Row | undefined)?.latestBuild ?? null) as Row | null;
-const lifecycleOf = (item: Row) => (item.lifecycle ?? {}) as Row;
+// The API sends a lifecycle on every backlog item (backlogItemSchema); a
+// response without one reads as no lifecycle rather than failing the wait.
+const latestBuildOf = (item: Item) => item.lifecycle?.latestBuild ?? null;
+const lifecycleOf = (item: Item): Partial<BacklogItemLifecycle> => item.lifecycle ?? {};
 
 /** What "changed" compares: where the item is, whose turn it is and how its latest run stands. */
-function itemSignature(item: Row): string {
+function itemSignature(item: Item): string {
   const lifecycle = lifecycleOf(item);
   const run = latestBuildOf(item);
   return JSON.stringify([
@@ -209,7 +216,7 @@ interface GateDefault {
  * the gate cannot be resolved (no gate of its own, and the product's default
  * unreadable) the answer is unknown, and the wait says so rather than guess.
  */
-function personTurn(item: Row, gate: GateDefault): 'yes' | 'no' | 'unknown' {
+function personTurn(item: Item, gate: GateDefault): 'yes' | 'no' | 'unknown' {
   const lifecycle = lifecycleOf(item);
   if (lifecycle.turn !== 'you') return 'no';
   if (lifecycle.cta !== 'start_build') return 'yes';
@@ -219,7 +226,7 @@ function personTurn(item: Row, gate: GateDefault): 'yes' | 'no' | 'unknown' {
   return resolveAutoBuild({ initiative: own, product: product ?? true }) ? 'no' : 'yes';
 }
 
-function itemHolds(until: ItemCondition, item: Row, first: Row, gate: GateDefault): boolean {
+function itemHolds(until: ItemCondition, item: Item, first: Item, gate: GateDefault): boolean {
   const lifecycle = lifecycleOf(item);
   const run = latestBuildOf(item);
   switch (until) {
@@ -239,7 +246,7 @@ function itemHolds(until: ItemCondition, item: Row, first: Row, gate: GateDefaul
 }
 
 function judgeItem(until: ItemCondition, gate: GateDefault) {
-  return (item: Row, first: Row): Verdict => {
+  return (item: Item, first: Item): Verdict => {
     if (itemHolds(until, item, first, gate)) return { reached: true };
     // "changed" is how a model waits for a person to act on a flagged or
     // finished initiative, so none of the stops below apply to it.
@@ -276,7 +283,7 @@ function judgeItem(until: ItemCondition, gate: GateDefault) {
 }
 
 /** The initiative as a wait reports it: where it is, whose turn, its latest run and its criteria. */
-function itemReport(item: Row) {
+function itemReport(item: Item) {
   const run = latestBuildOf(item);
   return {
     ...pickFields(
@@ -316,11 +323,11 @@ const RUN_REPORT_FIELDS = [
   'actions',
 ] as const;
 
-const runSignature = (run: Row) =>
+const runSignature = (run: Run) =>
   JSON.stringify([run.status, run.completedSteps, run.prUrl, run.prState, run.prMerged]);
 
 function judgeBuild(until: BuildCondition) {
-  return (run: Row, first: Row): Verdict => {
+  return (run: Run, first: Run): Verdict => {
     const holds =
       until === 'changed'
         ? runSignature(run) !== runSignature(first)
@@ -367,14 +374,14 @@ export function registerWaitTools(server: McpServer, client: TaigaClient, option
         runTool(async () => {
           const gate: GateDefault = { product: undefined };
           const read = async (signal: AbortSignal) => {
-            const item = (await client.getBacklogItem(params.itemId, signal)).data as Row;
+            const item = (await client.getBacklogItem(params.itemId, signal)).data;
             // The product's default, once, when this initiative has no gate of its own to answer with.
             if (gate.product === undefined && typeof item.autoBuild !== 'boolean') {
               gate.product = client.hasCapability('products:read')
                 ? await client
                     .getProduct(String(item.productId), signal)
                     .then((p) => {
-                      const value = (p.data as { autoBuild?: unknown }).autoBuild;
+                      const value = p.data.autoBuild;
                       return typeof value === 'boolean' ? value : true;
                     })
                     // Not allowed, or gone: unknown for good. Anything transient
@@ -427,7 +434,7 @@ export function registerWaitTools(server: McpServer, client: TaigaClient, option
       (params, ctx) =>
         runTool(async () => {
           const result = await waitFor(
-            async (signal) => (await client.getBuildRun(params.buildId, signal)).data as Row,
+            async (signal) => (await client.getBuildRun(params.buildId, signal)).data,
             judgeBuild(params.until),
             (params.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS) * 1000,
             options,
@@ -466,7 +473,7 @@ export function registerWaitTools(server: McpServer, client: TaigaClient, option
       (params, ctx) =>
         runTool(async () => {
           const result = await waitFor(
-            async (signal) => (await client.getAgentJob(params.jobId, signal)).data as Row,
+            async (signal) => (await client.getAgentJob(params.jobId, signal)).data,
             (job) => (SETTLED_JOB_STATUSES.has(String(job.status)) ? { reached: true } : null),
             (params.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS) * 1000,
             options,

package/tsconfig.json

@@ -13,11 +13,7 @@
 
     // @tsconfig/strictest leaves these two out, so every package sets them.
     "verbatimModuleSyntax": true,
-    "erasableSyntaxOnly": true,
-
-    // Preset flags this package still fails (PRO-2509). Each line is deleted
-    // by the issue named beside it; no new line is added here.
-    "noPropertyAccessFromIndexSignature": false // PRO-2519
+    "erasableSyntaxOnly": true
   },
   "include": ["src"],
   "exclude": ["node_modules", "dist"],