@daghis/teamcity-mcp 0.1.2 → 0.1.3

package/src/swagger/swagger-validator.ts

@@ -1,212 +0,0 @@
-/**
- * TeamCity Swagger specification validator
- */
-import { info, warn } from '@/utils/logger';
-
-import type { SwaggerSpec } from './swagger-fetcher';
-
-export interface ValidationResult {
-  isValid: boolean;
-  errors?: string[];
-  warnings?: string[];
-  version?: string;
-  teamCityVersion?: string;
-  hasRequiredPaths?: boolean;
-}
-
-export class SwaggerValidator {
-  private requiredPaths = [
-    '/app/rest/builds',
-    '/app/rest/projects',
-    '/app/rest/buildTypes',
-    '/app/rest/vcs-roots',
-  ];
-
-  /**
-   * Validate a Swagger/OpenAPI specification
-   */
-  validateSpec(spec: unknown): ValidationResult {
-    const errors: string[] = [];
-    const warnings: string[] = [];
-
-    if (!this.isValidSpec(spec)) {
-      errors.push('Invalid specification format');
-      return { isValid: false, errors };
-    }
-
-    const typedSpec = spec;
-
-    // Check for required fields
-    if (typedSpec.info === undefined || typedSpec.info === null) {
-      errors.push('Missing required fields: info');
-    }
-    if (typedSpec.paths === undefined || typedSpec.paths === null) {
-      errors.push('Missing required fields: paths');
-    }
-
-    // Determine spec version
-    const version = typedSpec.swagger ?? typedSpec.openapi;
-    if (version === undefined || version === null || version === '') {
-      errors.push('Missing specification version (swagger or openapi field)');
-    }
-
-    // Extract TeamCity version
-    const teamCityVersion = this.extractTeamCityVersion(typedSpec);
-
-    // Check for required paths
-    const hasRequiredPaths = this.checkRequiredPaths(typedSpec);
-    if (!hasRequiredPaths) {
-      warnings.push('Some required TeamCity API paths are missing');
-    }
-
-    // Validate spec version compatibility
-    if (version !== undefined && version !== null && version !== '') {
-      if (version.startsWith('2.')) {
-        info('Detected Swagger 2.0 specification');
-      } else if (version.startsWith('3.')) {
-        info('Detected OpenAPI 3.0 specification');
-      } else {
-        warnings.push(`Unknown specification version: ${version}`);
-      }
-    }
-
-    const isValid = errors.length === 0;
-
-    if (isValid) {
-      info('Swagger specification validation passed', {
-        version,
-        teamCityVersion,
-        pathCount: Object.keys(typedSpec.paths ?? {}).length,
-      });
-    } else {
-      warn('Swagger specification validation failed', { errors });
-    }
-
-    const result: ValidationResult = { isValid };
-
-    if (version !== undefined) {
-      result.version = version;
-    }
-
-    if (teamCityVersion !== undefined) {
-      result.teamCityVersion = teamCityVersion;
-    }
-
-    if (hasRequiredPaths !== undefined) {
-      result.hasRequiredPaths = hasRequiredPaths;
-    }
-
-    if (errors.length > 0) {
-      result.errors = errors;
-    }
-
-    if (warnings.length > 0) {
-      result.warnings = warnings;
-    }
-
-    return result;
-  }
-
-  /**
-   * Type guard to check if object is a valid spec
-   */
-  private isValidSpec(spec: unknown): spec is SwaggerSpec {
-    if (spec === null || spec === undefined || typeof spec !== 'object') {
-      return false;
-    }
-
-    const obj = spec as Record<string, unknown>;
-
-    // Must have either swagger or openapi field
-    if (!('swagger' in obj) && !('openapi' in obj)) {
-      return false;
-    }
-
-    // Must have info object
-    if (obj['info'] === null || obj['info'] === undefined || typeof obj['info'] !== 'object') {
-      return false;
-    }
-
-    const info = obj['info'] as Record<string, unknown>;
-
-    // Info must have version and title
-    if (info['version'] === null || info['version'] === undefined || info['title'] === undefined) {
-      return false;
-    }
-
-    return true;
-  }
-
-  /**
-   * Extract TeamCity version from spec
-   */
-  private extractTeamCityVersion(spec: SwaggerSpec): string | undefined {
-    // TeamCity version is typically in info.version
-    const version = spec.info?.version;
-    if (version !== undefined && version !== '') {
-      // TeamCity versions look like "2023.11.2" or "2024.1"
-      const versionMatch = version.match(/\d{4}\.\d{1,2}(?:\.\d+)?/);
-      if (versionMatch) {
-        return versionMatch[0];
-      }
-    }
-
-    // Fallback: check description for version info
-    const description = spec.info?.description;
-    if (description !== undefined && description !== '') {
-      const versionMatch = description.match(/TeamCity (\d{4}\.\d{1,2}(?:\.\d+)?)/);
-      if (versionMatch) {
-        return versionMatch[1];
-      }
-    }
-
-    return version; // Return raw version if no pattern match
-  }
-
-  /**
-   * Check if spec contains required TeamCity paths
-   */
-  private checkRequiredPaths(spec: SwaggerSpec): boolean {
-    if (spec.paths === undefined || spec.paths === null) {
-      return false;
-    }
-
-    const paths = Object.keys(spec.paths);
-    const foundPaths = this.requiredPaths.filter((required) =>
-      paths.some((path) => path.startsWith(required))
-    );
-
-    return foundPaths.length >= this.requiredPaths.length / 2; // At least half should be present
-  }
-
-  /**
-   * Check if TeamCity version is supported
-   */
-  isVersionSupported(version: string): boolean {
-    // We support TeamCity 2020.1 and later
-    const minYear = 2020;
-    const minMinor = 1;
-
-    const match = version.match(/(\d{4})\.(\d{1,2})/);
-    if (
-      match?.[1] === undefined ||
-      match?.[1] === '' ||
-      match[2] === undefined ||
-      match[2] === ''
-    ) {
-      return false;
-    }
-
-    const year = parseInt(match[1], 10);
-    const minor = parseInt(match[2], 10);
-
-    if (year < minYear) {
-      return false;
-    }
-    if (year === minYear && minor < minMinor) {
-      return false;
-    }
-
-    return true;
-  }
-}

package/src/teamcity/api-types.ts

@@ -1,387 +0,0 @@
-/**
- * TeamCity API Response Type Definitions
- *
- * Comprehensive type definitions for TeamCity REST API responses
- * to improve type safety throughout the codebase.
- */
-
-/**
- * Common property structure used in TeamCity API responses
- */
-export interface TeamCityProperty {
-  name: string;
-  value: string;
-  inherited?: boolean;
-  type?: {
-    rawValue?: string;
-  };
-}
-
-/**
- * Properties collection used in various API responses
- */
-export interface TeamCityProperties {
-  count?: number;
-  property?: TeamCityProperty | TeamCityProperty[];
-}
-
-/**
- * Build trigger API response structure
- */
-export interface TeamCityTriggerResponse {
-  id: string;
-  type: string;
-  disabled?: boolean;
-  inherited?: boolean;
-  properties?: TeamCityProperties;
-}
-
-/**
- * Build triggers collection response
- */
-export interface TeamCityTriggersResponse {
-  count?: number;
-  trigger?: TeamCityTriggerResponse | TeamCityTriggerResponse[];
-}
-
-/**
- * Build step API response structure
- */
-export interface TeamCityStepResponse {
-  id: string;
-  name: string;
-  type: string;
-  disabled?: boolean;
-  inherited?: boolean;
-  properties?: TeamCityProperties;
-}
-
-/**
- * Build steps collection response
- */
-export interface TeamCityStepsResponse {
-  count?: number;
-  step?: TeamCityStepResponse | TeamCityStepResponse[];
-}
-
-/**
- * VCS root entry response
- */
-export interface TeamCityVcsRootEntry {
-  id: string;
-  inherited?: boolean;
-  'checkout-rules'?: string;
-  'vcs-root': {
-    id: string;
-    name: string;
-    href?: string;
-    properties?: TeamCityProperties;
-  };
-}
-
-/**
- * VCS root entries collection
- */
-export interface TeamCityVcsRootEntriesResponse {
-  count?: number;
-  'vcs-root-entry'?: TeamCityVcsRootEntry | TeamCityVcsRootEntry[];
-}
-
-/**
- * Build type (configuration) response
- */
-export interface TeamCityBuildTypeResponse {
-  id: string;
-  name: string;
-  projectId: string;
-  projectName?: string;
-  description?: string;
-  webUrl?: string;
-  paused?: boolean;
-  templateFlag?: boolean;
-  parameters?: TeamCityProperties;
-  settings?: TeamCityProperties;
-  'vcs-root-entries'?: TeamCityVcsRootEntriesResponse;
-  triggers?: TeamCityTriggersResponse;
-  steps?: TeamCityStepsResponse;
-  features?: {
-    count?: number;
-    feature?: Array<{
-      id: string;
-      type: string;
-      properties?: TeamCityProperties;
-    }>;
-  };
-  'snapshot-dependencies'?: {
-    count?: number;
-    'snapshot-dependency'?: Array<{
-      id: string;
-      type: string;
-      properties?: TeamCityProperties;
-      'source-buildType': {
-        id: string;
-        name: string;
-      };
-    }>;
-  };
-  'artifact-dependencies'?: {
-    count?: number;
-    'artifact-dependency'?: Array<{
-      id: string;
-      type: string;
-      properties?: TeamCityProperties;
-      'source-buildType': {
-        id: string;
-        name: string;
-      };
-    }>;
-  };
-}
-
-/**
- * Build types collection response
- */
-export interface TeamCityBuildTypesResponse {
-  count?: number;
-  buildType?: TeamCityBuildTypeResponse | TeamCityBuildTypeResponse[];
-}
-
-/**
- * Project response structure
- */
-export interface TeamCityProjectResponse {
-  id: string;
-  name: string;
-  parentProjectId?: string;
-  href?: string;
-  webUrl?: string;
-  description?: string;
-  archived?: boolean;
-  parameters?: TeamCityProperties;
-  projects?: {
-    count?: number;
-    project?: TeamCityProjectResponse | TeamCityProjectResponse[];
-  };
-  buildTypes?: TeamCityBuildTypesResponse;
-}
-
-/**
- * Projects collection response
- */
-export interface TeamCityProjectsResponse {
-  count?: number;
-  project?: TeamCityProjectResponse | TeamCityProjectResponse[];
-}
-
-/**
- * Build response structure
- */
-export interface TeamCityBuildResponse {
-  id: number;
-  buildTypeId: string;
-  number?: string;
-  status?: 'SUCCESS' | 'FAILURE' | 'ERROR' | 'UNKNOWN';
-  state?: 'queued' | 'running' | 'finished';
-  branchName?: string;
-  defaultBranch?: boolean;
-  href?: string;
-  webUrl?: string;
-  statusText?: string;
-  buildType?: {
-    id: string;
-    name: string;
-    projectId: string;
-    projectName: string;
-  };
-  queuedDate?: string;
-  startDate?: string;
-  finishDate?: string;
-  running?: boolean;
-  percentageComplete?: number;
-  properties?: TeamCityProperties;
-  tags?: {
-    count?: number;
-    tag?: Array<{
-      name: string;
-    }>;
-  };
-  revisions?: {
-    count?: number;
-    revision?: Array<{
-      version: string;
-      vcsBranchName?: string;
-      'vcs-root-instance': {
-        id: string;
-        name: string;
-      };
-    }>;
-  };
-  changes?: {
-    count?: number;
-    change?: Array<{
-      id: number;
-      version: string;
-      username: string;
-      date: string;
-      comment?: string;
-    }>;
-  };
-  artifacts?: {
-    count?: number;
-    file?: Array<{
-      name: string;
-      size: number;
-      modificationTime: string;
-      href?: string;
-      content?: {
-        href: string;
-      };
-    }>;
-  };
-  problemOccurrences?: {
-    count?: number;
-    problemOccurrence?: Array<{
-      id: string;
-      type: string;
-      identity: string;
-      details?: string;
-      additionalData?: string;
-    }>;
-  };
-  testOccurrences?: {
-    count?: number;
-    testOccurrence?: Array<{
-      id: string;
-      name: string;
-      status: 'SUCCESS' | 'FAILURE' | 'IGNORED' | 'UNKNOWN';
-      duration?: number;
-      details?: string;
-    }>;
-  };
-}
-
-/**
- * Builds collection response
- */
-export interface TeamCityBuildsResponse {
-  count?: number;
-  build?: TeamCityBuildResponse | TeamCityBuildResponse[];
-}
-
-/**
- * Error response structure
- */
-export interface TeamCityErrorResponse {
-  message?: string;
-  details?: string;
-}
-
-/**
- * Type guards for safe type checking
- */
-export const isTeamCityErrorResponse = (response: unknown): response is TeamCityErrorResponse => {
-  return typeof response === 'object' && response !== null && 'message' in response;
-};
-
-export const isPropertyArray = (
-  prop: TeamCityProperty | TeamCityProperty[] | undefined
-): prop is TeamCityProperty[] => {
-  return Array.isArray(prop);
-};
-
-export const isTriggerArray = (
-  trigger: TeamCityTriggerResponse | TeamCityTriggerResponse[] | undefined
-): trigger is TeamCityTriggerResponse[] => {
-  return Array.isArray(trigger);
-};
-
-export const isStepArray = (
-  step: TeamCityStepResponse | TeamCityStepResponse[] | undefined
-): step is TeamCityStepResponse[] => {
-  return Array.isArray(step);
-};
-
-export const isBuildTypeArray = (
-  buildType: TeamCityBuildTypeResponse | TeamCityBuildTypeResponse[] | undefined
-): buildType is TeamCityBuildTypeResponse[] => {
-  return Array.isArray(buildType);
-};
-
-export const isVcsRootEntryArray = (
-  entry: TeamCityVcsRootEntry | TeamCityVcsRootEntry[] | undefined
-): entry is TeamCityVcsRootEntry[] => {
-  return Array.isArray(entry);
-};
-
-/**
- * Helper function to normalize properties to array
- */
-export function normalizeProperties(
-  properties: TeamCityProperties | undefined
-): TeamCityProperty[] {
-  if (!properties?.property) {
-    return [];
-  }
-  return isPropertyArray(properties.property) ? properties.property : [properties.property];
-}
-
-/**
- * Helper function to normalize triggers to array
- */
-export function normalizeTriggers(
-  response: TeamCityTriggersResponse | undefined
-): TeamCityTriggerResponse[] {
-  if (!response?.trigger) {
-    return [];
-  }
-  return isTriggerArray(response.trigger) ? response.trigger : [response.trigger];
-}
-
-/**
- * Helper function to normalize steps to array
- */
-export function normalizeSteps(
-  response: TeamCityStepsResponse | undefined
-): TeamCityStepResponse[] {
-  if (!response?.step) {
-    return [];
-  }
-  return isStepArray(response.step) ? response.step : [response.step];
-}
-
-/**
- * Helper function to normalize build types to array
- */
-export function normalizeBuildTypes(
-  response: TeamCityBuildTypesResponse | undefined
-): TeamCityBuildTypeResponse[] {
-  if (!response?.buildType) {
-    return [];
-  }
-  return isBuildTypeArray(response.buildType) ? response.buildType : [response.buildType];
-}
-
-/**
- * Helper function to normalize VCS root entries to array
- */
-export function normalizeVcsRootEntries(
-  response: TeamCityVcsRootEntriesResponse | undefined
-): TeamCityVcsRootEntry[] {
-  if (!response?.['vcs-root-entry']) {
-    return [];
-  }
-  return isVcsRootEntryArray(response['vcs-root-entry'])
-    ? response['vcs-root-entry']
-    : [response['vcs-root-entry']];
-}
-
-/**
- * Helper to extract properties as a typed record
- */
-export function propertiesToRecord(properties: TeamCityProperty[]): Record<string, string> {
-  const record: Record<string, string> = {};
-  properties.forEach((prop) => {
-    record[prop.name] = prop.value;
-  });
-  return record;
-}