@taiga-ai/mcp-server 0.25.0-rc.474 → 0.26.0-dev.481

package/src/tools/readiness.ts

@@ -1,177 +0,0 @@
-import { TaigaApiError, type TaigaClient } from '../client.js';
-import { PRODUCT_DOCUMENT_NAMES, isImportedProduct, setupNextStep, type ProductSettingsView } from './catalogue.js';
-import { isNetworkFailure } from './errors.js';
-
-type Row = Record<string, unknown>;
-
-/**
- * What a product in setup still needs, read rather than learned from a
- * refused write (PRO-2800). A reviewing agent linked a repository and picked
- * a branch, and every read still said "link its repository": nextStep read
- * the Discovery step alone, and the only way to see the missing documents was
- * to call taiga_finish_discovery and read its refusal. This reads the same
- * preconditions the API refuses on (GET /products/:id/setup), the linked
- * repositories and the import, and says the one next move.
- */
-export interface Readiness {
-  /** Whether taiga_finish_discovery would succeed now. Null when the API could not say. */
-  ready: boolean | null;
-  /** Null when the links could not be read: not the same as none linked. */
-  repository: { linked: false } | { linked: true; name: unknown; branch: unknown } | null;
-  /** An imported product's import, as its settings.importStatus says it: pending (not started), analyzing or generating_docs (running), complete, failed, cancelled. */
-  import?: string;
-  discoveryStep?: unknown;
-  /** The required documents not yet published, as the type taiga_get_product_document takes; null when the API could not say. */
-  missingDocuments: string[] | null;
-  /** The required checks not yet stamped (stamped in the web); null when the API could not say. */
-  openChecks: string[] | null;
-  /** The one move that gets it closer; null when too little could be read to say. */
-  nextStep: string | null;
-}
-
-const IMPORT_STATE: Record<string, string> = {
-  pending: 'not started',
-  analyzing: 'running',
-  generating_docs: 'running',
-  complete: 'complete',
-  failed: 'failed',
-  cancelled: 'failed',
-};
-
-/** A failure that is the API's (refused, missing, unreachable), not a bug in this code. */
-function isApiSide(error: unknown): boolean {
-  return error instanceof TaigaApiError || isNetworkFailure(error);
-}
-
-/** The documents by the names the web uses. */
-function named(types: string[]): string {
-  return types.map((type) => PRODUCT_DOCUMENT_NAMES[type as keyof typeof PRODUCT_DOCUMENT_NAMES] ?? type).join(', ');
-}
-
-/** The product's setup readiness, or null once it has finished setup. */
-export async function setupReadiness(
-  client: TaigaClient,
-  product: Row,
-  /** The product's repository links when the caller is reading them anyway (the context), so one read serves both. */
-  links?: () => Promise<{ data: unknown[] }>
-): Promise<Readiness | null> {
-  if (product['status'] !== 'draft') return null;
-  const id = String(product['id']);
-  const imported = isImportedProduct(product as ProductSettingsView);
-  const [repos, blockers, full] = await Promise.all([
-    (links ? links() : client.listProductRepositories(id)).then(
-      (result) => result.data as Row[],
-      (error: unknown) => {
-        if (isApiSide(error)) return null;
-        throw error;
-      }
-    ),
-    // An API from before the read answers 404 to it: fall back to the step.
-    client.getProductSetupBlockers(id).then(
-      (result) => result.data,
-      (error: unknown) => {
-        if (isApiSide(error)) return null;
-        throw error;
-      }
-    ),
-    // A write's answer carries no discoveryStep; the read derives it.
-    'discoveryStep' in product || imported
-      ? Promise.resolve(product)
-      : client.getProduct(id).then(
-          (result) => result.data as Row,
-          (error: unknown) => {
-            if (isApiSide(error)) return product;
-            throw error;
-          }
-        ),
-  ]);
-
-  const link = repos?.[0];
-  const repository = !repos
-    ? null
-    : link
-      ? { linked: true as const, name: link['repositoryName'], branch: link['effectiveBranch'] }
-      : { linked: false as const };
-  const settings = (product['settings'] ?? {}) as { importStatus?: unknown };
-  const importState = imported ? (IMPORT_STATE[String(settings.importStatus)] ?? 'not started') : undefined;
-  const missing = blockers ? blockers.missingDocuments : null;
-  const openChecks = blockers ? blockers.openChecks.map((check) => check.criterion) : null;
-  // What the API refuses on, nothing else: a running import is in nextStep, not a blocker.
-  const ready = blockers ? missing!.length === 0 && openChecks!.length === 0 : null;
-
-  return {
-    ready,
-    repository,
-    ...(imported ? { import: typeof settings.importStatus === 'string' ? settings.importStatus : 'pending' } : {}),
-    ...(imported ? {} : { discoveryStep: full['discoveryStep'] ?? null }),
-    missingDocuments: missing,
-    openChecks,
-    nextStep: nextStepFor({
-      imported,
-      importState,
-      linked: repository?.linked ?? null,
-      missing,
-      openChecks,
-      product: full,
-    }),
-  };
-}
-
-function nextStepFor(state: {
-  imported: boolean;
-  importState: string | undefined;
-  /** Null when the links could not be read. */
-  linked: boolean | null;
-  missing: string[] | null;
-  openChecks: string[] | null;
-  product: Row;
-}): string | null {
-  const finish =
-    'taiga_finish_discovery opens the product and locks its documents (ask the person: it is their decision ' +
-    'that the documents are right).';
-  if (state.imported) {
-    if (state.linked === false) {
-      return 'Link its repository (taiga_list_linkable_repositories, then taiga_link_repository), then taiga_start_import.';
-    }
-    if (state.linked === null && state.importState === 'not started')
-      return setupNextStep(state.product as ProductSettingsView);
-    switch (state.importState) {
-      case 'running':
-        return 'The import is running and derives the documents from the code; taiga_wait_for_job follows it.';
-      case 'failed':
-        return 'The last import did not finish: taiga_start_import runs it again.';
-      case 'complete':
-        if (state.missing && state.missing.length > 0) {
-          return (
-            `The import finished but ${named(state.missing)} ${state.missing.length === 1 ? 'is' : 'are'} not ` +
-            'published: taiga_get_product_document without type shows them, taiga_publish_product_document publishes a draft.'
-          );
-        }
-        return `The import is done: review the reality documents (taiga_get_product_document without type), then ${finish}`;
-      default:
-        return 'taiga_start_import derives the documents from the code and runs by itself (paid agent work: ask first).';
-    }
-  }
-  // Without the API's read, the Discovery step is all there is to go on, and
-  // without that, nothing: a guess would send a product at its documents back
-  // to the conversation.
-  if (!state.missing) return setupNextStep(state.product as ProductSettingsView);
-  if (state.missing.includes('specification')) {
-    return (
-      'The specification comes from the Discovery conversation, held in the web: the person describes the ' +
-      'product there. The other documents follow from it.' +
-      (state.linked === false
-        ? ' Linking a repository (taiga_link_repository) can wait until before the first build.'
-        : '')
-    );
-  }
-  if (state.missing.length > 0) {
-    return (
-      `Still to publish: ${named(state.missing)}. taiga_generate_product_documents generates the missing ones ` +
-      '(paid agent work: ask first); a draft is published with taiga_publish_product_document.'
-    );
-  }
-  if (state.openChecks && state.openChecks.length > 0)
-    return `The documents are published; the checks are stamped in the web, then ${finish}`;
-  return `Every required document is published: ${finish}`;
-}

package/src/tools/remote.test.ts

@@ -1,44 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseRemote } from './remote.js';
-
-describe('parseRemote', () => {
-  it.each([
-    ['https://github.com/acme/web.git', 'https://github.com', 'acme/web'],
-    ['https://github.com/acme/web', 'https://github.com', 'acme/web'],
-    ['https://github.com/acme/web/', 'https://github.com', 'acme/web'],
-    ['https://github.com/acme/web.git/', 'https://github.com', 'acme/web'],
-    ['git@github.com:acme/web.git/', 'https://github.com', 'acme/web'],
-    ['https://user@GitHub.com/Acme/Web.git', 'https://github.com', 'Acme/Web'],
-    ['http://ghe.local:8443/acme/web.git', 'http://ghe.local:8443', 'acme/web'],
-    ['ssh://git@github.com/acme/web.git', 'https://github.com', 'acme/web'],
-    ['ssh://git@ghe.example.com:2222/acme/web.git', 'https://ghe.example.com', 'acme/web'],
-    ['git+ssh://git@github.com/acme/web.git', 'https://github.com', 'acme/web'],
-    ['git@github.com:acme/web.git', 'https://github.com', 'acme/web'],
-    ['git@taiga.ghe.com:taiga/taiga-app.git', 'https://taiga.ghe.com', 'taiga/taiga-app'],
-    ['  git@github.com:acme/web.git\n', 'https://github.com', 'acme/web'],
-    ['https://g/acme/web', 'https://g', 'acme/web'],
-  ])('reads %s as %s %s', (remote, host, repository) => {
-    expect(parseRemote(remote)).toEqual({ host, repository });
-  });
-
-  it.each([
-    [''],
-    ['not a remote'],
-    ['https://github.com/acme'],
-    ['https://gitlab.com/group/subgroup/repo.git'],
-    ['https://github.com/acme/../web'],
-    ['https://github.com/acme/tmp/../web'],
-    ['https://github.com/acme/tmp/%2e%2e/web'],
-    ['https://github.com/acme/./web'],
-    ['git@github.com:acme/tmp/../web.git'],
-    ['ftp://github.com/acme/web'],
-    ['/Users/dev/acme/web'],
-    ['C:/acme/web'],
-    ['git@ghe.local:8443:acme/web.git'],
-    ['git@github[.]com:acme/web.git'],
-    ['git@git hub.com:acme/web.git'],
-    ['acme/web'],
-  ])('refuses %s', (remote) => {
-    expect(parseRemote(remote)).toBeNull();
-  });
-});

package/src/tools/remote.ts

@@ -1,107 +0,0 @@
-/**
- * What a git remote says about where a repository lives, in the terms Taiga
- * stores: the web origin of the host and the `owner/repo` name. A developer's
- * checkout knows its remote, not its Taiga product; this is the bridge.
- *
- * Accepted shapes: `https://host/owner/repo(.git)`, `ssh://git@host/owner/repo`,
- * `git+ssh://...` and the scp-like `git@host:owner/repo.git`. Anything else,
- * and any path that is not exactly two segments, is null: Taiga links
- * `owner/repo` names only, so a deeper path can never match a link.
- *
- * An SSH remote names no web origin, so it is read as `https://host` on the
- * default port. A host whose web UI sits on another port or on plain http
- * does not resolve from its SSH remote; the https remote does.
- */
-export interface ParsedRemote {
-  /** The web origin the link's URL starts with, such as `https://github.com`. */
-  host: string;
-  /** `owner/repo`, in the caller's case; the API matches it case-insensitively. */
-  repository: string;
-}
-
-const SCP_LIKE = /^(?:[^@\s/]+@)?([^:\s/]+):([^\s]+)$/;
-
-export function parseRemote(remote: string): ParsedRemote | null {
-  const trimmed = remote.trim();
-  if (trimmed === '') return null;
-
-  let host: string;
-  let path: string;
-  let scheme = 'https';
-
-  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed)) {
-    // The URL parser folds `..` away before the path can be looked at, so
-    // the raw text after the authority is checked first: a dot segment in a
-    // remote is never what `git remote get-url` prints.
-    if (hasDotSegment(trimmed.replace(/^[a-z][a-z0-9+.-]*:\/\/[^/]*/i, ''))) return null;
-    let url: URL;
-    try {
-      url = new URL(trimmed);
-    } catch {
-      return null;
-    }
-    const protocol = url.protocol.replace(/:$/, '').toLowerCase();
-    if (protocol === 'http' || protocol === 'https') {
-      scheme = protocol;
-      // The port is part of the web origin a link was stored with.
-      host = url.port ? `${url.hostname}:${url.port}` : url.hostname;
-    } else if (protocol === 'ssh' || protocol === 'git+ssh' || protocol === 'git') {
-      // An SSH port says nothing about the web origin.
-      host = url.hostname;
-    } else {
-      return null;
-    }
-    path = url.pathname;
-  } else {
-    const match = SCP_LIKE.exec(trimmed);
-    if (!match) return null;
-    host = match[1]!;
-    path = match[2]!;
-    // Only this shape can misread a Windows drive (`C:/acme/web`) as a host;
-    // an explicit URL with a one-letter hostname is what it says it is.
-    if (host.length < 2) return null;
-  }
-
-  host = host.toLowerCase();
-  if (host === '') return null;
-
-  const segments = path
-    .replace(/\/+$/, '')
-    .replace(/\.git$/i, '')
-    .split('/')
-    .filter((segment) => segment !== '');
-  if (segments.length !== 2) return null;
-  // `.`/`..` would collapse into another route; a ':' is a port that landed
-  // in the path (`git@host:8443:owner/repo`), which no link name carries.
-  if (hasDotSegment(path) || segments.some((segment) => segment.includes(':'))) return null;
-
-  // The scp-like shape takes any host-looking text; only an origin the URL
-  // parser accepts is sent on, so `git@github[.]com:acme/web` is refused
-  // here rather than by the API after a request.
-  const origin = webOrigin(`${scheme}://${host}`);
-  if (origin === null) return null;
-
-  return { host: origin, repository: `${segments[0]}/${segments[1]}` };
-}
-
-/** Whether any segment of the path is `.` or `..`, percent-encoded or not. */
-function hasDotSegment(path: string): boolean {
-  return path.split('/').some((segment) => {
-    let decoded = segment;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-      // An undecodable segment is kept as is; it is not a dot segment.
-    }
-    return decoded === '.' || decoded === '..';
-  });
-}
-
-function webOrigin(url: string): string | null {
-  try {
-    const origin = new URL(url).origin;
-    return origin === 'null' ? null : origin;
-  } catch {
-    return null;
-  }
-}