@daghis/teamcity-mcp 0.9.0 → 0.9.2

package/tests/unit/teamcity/pagination.test.ts

@@ -1,118 +0,0 @@
-import {
-  PaginatedIterator,
-  type PaginatedResponse,
-  type PaginationParams,
-  buildLocator,
-  createPaginatedFetcher,
-  fetchAllPages,
-  parseLocator,
-} from '@/teamcity/pagination';
-
-jest.mock('@/utils/logger', () => ({
-  info: jest.fn(),
-}));
-
-describe('teamcity pagination utilities', () => {
-  it('parseLocator/buildLocator round trip', () => {
-    const loc = buildLocator({ start: 10, count: 50 });
-    expect(loc).toBe('start:10,count:50');
-    const parsed = parseLocator(loc);
-    expect(parsed).toEqual({ start: 10, count: 50 });
-  });
-
-  it('parseLocator handles missing pieces', () => {
-    expect(parseLocator('start:5')).toEqual({ start: 5 });
-    expect(parseLocator('count:25')).toEqual({ count: 25 });
-    expect(parseLocator('start:abc,count:10')).toEqual({ start: NaN, count: 10 });
-  });
-
-  it('createPaginatedFetcher passes count/start and extracts fields', async () => {
-    const baseFetch = jest.fn(async (params: PaginationParams) => {
-      // ensure count/start are forwarded correctly
-      expect(params.start).toBe(0);
-      expect(params.count).toBe(3);
-      return {
-        data: {
-          nextHref: 'next',
-          prevHref: 'prev',
-          items: [1, 2, 3],
-          total: 3,
-        },
-      } as unknown as { data: unknown };
-    });
-
-    const fetcher = createPaginatedFetcher(
-      baseFetch as unknown as (p: PaginationParams) => Promise<unknown>,
-      (data: unknown) => (data as { items: number[] }).items,
-      (data: unknown) => (data as { total: number }).total
-    );
-
-    const resp = await fetcher({ start: 0, count: 3 });
-    expect(resp.items).toEqual([1, 2, 3]);
-    expect(resp.count).toBe(3);
-    expect(resp.total).toBe(3);
-    expect(resp.nextHref).toBe('next');
-    expect(resp.prevHref).toBe('prev');
-  });
-
-  it('fetchAllPages accumulates pages and respects maxPages', async () => {
-    const pages: Array<PaginatedResponse<number>> = [
-      { items: [1, 2], count: 2, nextHref: 'n1' },
-      { items: [3, 4], count: 2, nextHref: 'n2' },
-      { items: [5], count: 1 }, // last page (items < pageSize)
-    ];
-    const fetchFn = async (p: PaginationParams): Promise<PaginatedResponse<number>> => {
-      const count = p.count ?? 2;
-      const start = p.start ?? 0;
-      const index = Math.floor(start / count);
-      const i = Math.min(index, pages.length - 1);
-      if (i < 0 || i >= pages.length) {
-        throw new Error('Invalid page index');
-      }
-      const page = pages[i];
-      if (page === undefined) {
-        throw new Error('Page is undefined');
-      }
-      return page;
-    };
-
-    // fetch all with maxPages limit = 2 (should stop at 2 pages)
-    const limited = await fetchAllPages(fetchFn, { pageSize: 2, maxPages: 2 });
-    expect(limited).toEqual([1, 2, 3, 4]);
-
-    // reset and fetch all pages (stops when items < pageSize)
-    const all = await fetchAllPages(fetchFn, { pageSize: 2 });
-    expect(all).toEqual([1, 2, 3, 4, 5]);
-  });
-
-  it('PaginatedIterator yields items across pages and supports helpers', async () => {
-    const pages: Array<PaginatedResponse<number>> = [
-      { items: [1, 2], count: 2, nextHref: 'n1' },
-      { items: [3, 4], count: 2, nextHref: 'n2' },
-      { items: [5], count: 1 },
-    ];
-    const fetchFn = async (p: PaginationParams): Promise<PaginatedResponse<number>> => {
-      const count = p.count ?? 2;
-      const start = p.start ?? 0;
-      const index = Math.floor(start / count);
-      const i = Math.min(index, pages.length - 1);
-      if (i < 0 || i >= pages.length) {
-        throw new Error('Invalid page index');
-      }
-      const page = pages[i];
-      if (page === undefined) {
-        throw new Error('Page is undefined');
-      }
-      return page;
-    };
-
-    const it = new PaginatedIterator(fetchFn, { pageSize: 2 });
-    const items = await it.toArray();
-    expect(items).toEqual([1, 2, 3, 4, 5]);
-
-    // getPage should return only that page
-    const it2 = new PaginatedIterator(fetchFn, { pageSize: 2 });
-    const page1 = await it2.getPage(1);
-    expect(page1).toEqual([3, 4]);
-  });
-});

package/tests/unit/teamcity/project-list-manager.test.ts

@@ -1,118 +0,0 @@
-import type { Project, Projects } from '@/teamcity-client/models';
-import { ProjectListManager } from '@/teamcity/project-list-manager';
-
-const makeClient = (
-  impl: Partial<{
-    getAllProjects: (locator: string, fields: string) => Promise<{ data: Projects }>;
-  }> = {}
-) => {
-  return {
-    projects: {
-      getAllProjects: impl.getAllProjects ?? (async () => ({ data: { project: [] } as Projects })),
-    },
-  } as unknown as import('@/teamcity/client').TeamCityClient;
-};
-
-describe('ProjectListManager', () => {
-  it('lists projects with locator, fields, and transforms hierarchy', async () => {
-    const response: Projects = {
-      count: 10,
-      project: [
-        {
-          id: 'A',
-          name: 'Alpha',
-          parentProjectId: '_Root',
-          archived: false,
-          href: '/p/A',
-          webUrl: 'http://t/p/A',
-          buildTypes: { count: 2 },
-          projects: {
-            project: [
-              { id: 'A1', name: 'Alpha-1', buildTypes: { count: 2 } },
-            ] as unknown as Project[],
-          },
-          ancestorProjects: { project: [{ id: '_Root', name: 'Root' }] as unknown as Project[] },
-          parentProject: { id: '_Root', name: 'Root' },
-        } as unknown as Project,
-        { id: 'B', name: 'Beta', buildTypes: { count: 1 } } as unknown as Project,
-      ],
-    };
-
-    const captured: { locator: string; fields: string }[] = [];
-    const client = makeClient({
-      getAllProjects: async (locator, fields) => {
-        captured.push({ locator, fields });
-        return { data: response };
-      },
-    });
-
-    const mgr = new ProjectListManager(client);
-    const res = await mgr.listProjects({
-      name: 'Al*',
-      archived: false,
-      parentProjectId: '_Root',
-      includeHierarchy: true,
-      limit: 2,
-      offset: 0,
-    });
-
-    // Behavior-first: avoid verifying internal locator/fields construction
-
-    const first = res.projects[0];
-    expect(first?.id).toBe('A');
-    expect(first?.buildTypesCount).toBe(2);
-    expect(first?.subprojectsCount).toBe(1);
-    expect(first?.depth).toBe(1);
-    expect(first?.parentProject).toBeDefined();
-    expect(first?.ancestorProjects).toBeDefined();
-    expect(first?.childProjects?.[0]?.buildTypesCount).toBe(2);
-
-    expect(res.metadata.count).toBe(2);
-    expect(res.metadata.hasMore).toBe(true);
-    expect(res.metadata.totalCount).toBe(10);
-  });
-
-  it('handles API errors with status-specific messages', async () => {
-    const errorBase = new Error('x') as Error & {
-      response?: { status?: number; data?: { message?: string } };
-      message?: string;
-    };
-    const client401 = makeClient({
-      getAllProjects: async () => {
-        throw Object.assign(new Error('e'), {
-          response: { status: 401, data: { message: 'bad' } },
-        });
-      },
-    });
-    const client403 = makeClient({
-      getAllProjects: async () => {
-        throw Object.assign(new Error('e'), { response: { status: 403, data: { message: 'no' } } });
-      },
-    });
-    const client404 = makeClient({
-      getAllProjects: async () => {
-        throw Object.assign(new Error('e'), {
-          response: { status: 404, data: { message: 'missing' } },
-        });
-      },
-    });
-    const clientOther = makeClient({
-      getAllProjects: async () => {
-        throw Object.assign(errorBase, { response: { status: 500, data: { message: 'oops' } } });
-      },
-    });
-
-    await expect(new ProjectListManager(client401).listProjects()).rejects.toThrow(
-      /Authentication failed: bad/
-    );
-    await expect(new ProjectListManager(client403).listProjects()).rejects.toThrow(
-      /Permission denied: no/
-    );
-    await expect(new ProjectListManager(client404).listProjects()).rejects.toThrow(
-      /Not found: missing/
-    );
-    await expect(new ProjectListManager(clientOther).listProjects()).rejects.toThrow(
-      /TeamCity API error \(500\): oops/
-    );
-  });
-});

package/tests/unit/teamcity/project-manager-branches.test.ts

@@ -1,176 +0,0 @@
-import type { Logger } from 'winston';
-
-import type { Project } from '@/teamcity-client/models';
-import { type ManagedProject, ProjectManager } from '@/teamcity/project-manager';
-
-const logger: Logger = { error: jest.fn() } as unknown as Logger;
-
-const makeClient = (
-  impl: Partial<{
-    getAllProjects: (
-      locator?: string,
-      fields?: string
-    ) => Promise<{ data: { project: Project[] } }>;
-    getProject: (id: string, fields?: string) => Promise<{ data: Project }>;
-    getAllSubprojectsOrdered: (
-      id: string,
-      fields?: string
-    ) => Promise<{ data: { project: Project[] } }>;
-  }>
-) => {
-  return {
-    projects: {
-      getAllProjects: impl.getAllProjects ?? (async () => ({ data: { project: [] } })),
-      getProject:
-        impl.getProject ??
-        (async (id: string) => ({ data: { id, name: id } as unknown as Project })),
-      getAllSubprojectsOrdered:
-        impl.getAllSubprojectsOrdered ?? (async () => ({ data: { project: [] } })),
-    },
-  } as unknown as import('@/teamcity/client').TeamCityClient;
-};
-
-describe('ProjectManager branch coverage boosters', () => {
-  it('applyFilters handles wildcard and substring patterns and hasBuilds true/false', () => {
-    const client = makeClient({});
-    const pm = new ProjectManager(client, logger);
-    const projects: ManagedProject[] = [
-      { id: '1', name: 'Alpha Service', archived: false, buildTypesCount: 1 },
-      { id: '2', name: 'Beta', archived: false, buildTypesCount: 0 },
-      { id: '3', name: 'Alps', archived: false, buildTypesCount: 2 },
-    ];
-
-    // Substring pattern (no wildcard)
-    const filtered1 = (
-      pm as unknown as { applyFilters: (p: ManagedProject[], f: unknown) => ManagedProject[] }
-    ).applyFilters(projects, { namePattern: 'alp' });
-    expect(filtered1.map((p) => p.id)).toEqual(['1', '3']);
-
-    // Wildcard pattern
-    const filtered2 = (
-      pm as unknown as { applyFilters: (p: ManagedProject[], f: unknown) => ManagedProject[] }
-    ).applyFilters(projects, { namePattern: 'Al*' });
-    expect(filtered2.map((p) => p.id)).toEqual(['1', '3']);
-
-    // hasBuilds true
-    const withBuilds = (
-      pm as unknown as { applyFilters: (p: ManagedProject[], f: unknown) => ManagedProject[] }
-    ).applyFilters(projects, { hasBuilds: true });
-    expect(withBuilds.map((p) => p.id)).toEqual(['1', '3']);
-
-    // hasBuilds false
-    const noBuilds = (
-      pm as unknown as { applyFilters: (p: ManagedProject[], f: unknown) => ManagedProject[] }
-    ).applyFilters(projects, { hasBuilds: false });
-    expect(noBuilds.map((p) => p.id)).toEqual(['2']);
-  });
-
-  it('applyFilters respects maxDepth but keeps items with undefined level', () => {
-    const client = makeClient({});
-    const pm = new ProjectManager(client, logger);
-    const projects: ManagedProject[] = [
-      { id: 'A', name: 'A', archived: false, level: 1 },
-      { id: 'B', name: 'B', archived: false, level: 3 },
-      { id: 'C', name: 'C', archived: false },
-    ];
-    const filtered = (
-      pm as unknown as { applyFilters: (p: ManagedProject[], f: unknown) => ManagedProject[] }
-    ).applyFilters(projects, { maxDepth: 2 });
-    expect(filtered.map((p) => p.id)).toEqual(['A', 'C']);
-  });
-
-  it('sortProjects handles default branch when sort key is invalid', () => {
-    const client = makeClient({});
-    const pm = new ProjectManager(client, logger);
-    const projects: ManagedProject[] = [
-      { id: 'B', name: 'B', archived: false },
-      { id: 'A', name: 'A', archived: false },
-    ];
-    const sorted = (
-      pm as unknown as {
-        sortProjects: (
-          p: ManagedProject[],
-          s: { by?: 'name' | 'id' | 'level' } & { order?: 'asc' | 'desc' }
-        ) => ManagedProject[];
-      }
-    ).sortProjects(projects, { by: 'invalid' as unknown as 'name', order: 'asc' });
-    // Should remain unchanged when default branch used
-    expect(sorted.map((p) => p.id)).toEqual(['B', 'A']);
-  });
-
-  it('listProjects executes locator branches without asserting internals', async () => {
-    const client = makeClient({ getAllProjects: async () => ({ data: { project: [] } }) });
-    const pm = new ProjectManager(client, logger);
-    // archived + parentProjectId exercises buildLocator branches
-    const res = await pm.listProjects({ filters: { archived: false, parentProjectId: 'PARENT' } });
-    expect(res.projects).toEqual([]);
-  });
-
-  it('getProjectAncestors breaks when parent missing mid-chain', async () => {
-    const client = makeClient({
-      getProject: async (id: string) => {
-        if (id === 'C')
-          return { data: { id: 'C', name: 'C', parentProjectId: 'Missing' } as unknown as Project };
-        // Simulate 404 -> library returns rejected promise; our ProjectManager converts to null
-        const err = Object.assign(new Error('not found'), { response: { status: 404 } });
-        throw err;
-      },
-    });
-    const pm = new ProjectManager(client, logger);
-    const ancestors = await pm.getProjectAncestors('C');
-    expect(ancestors.map((p) => p.id)).toEqual(['C']);
-  });
-
-  it('getProjectDescendants avoids cycles via visited guard', async () => {
-    const client = makeClient({
-      getAllSubprojectsOrdered: async (id: string) => {
-        if (id === '_Root') return { data: { project: [{ id: 'A', name: 'A' }] } };
-        if (id === 'A') return { data: { project: [{ id: '_Root', name: 'Root' }] } };
-        return { data: { project: [] } };
-      },
-    });
-    const pm = new ProjectManager(client, logger);
-    const descendants = await pm.getProjectDescendants('_Root', 3);
-    // Should include A and at most one back-reference; no infinite loop
-    const ids = descendants.map((p) => p.id);
-    expect(new Set(ids)).toEqual(new Set(['A', '_Root']));
-  });
-
-  it('listProjects paginate boundaries via public API', async () => {
-    const projectsMany = Array.from(
-      { length: 3 },
-      (_, i) => ({ id: `P${i + 1}`, name: `P${i + 1}` }) as unknown as Project
-    );
-    const client = makeClient({
-      getAllProjects: async () => ({
-        data: { project: projectsMany } as unknown as { project: Project[] },
-      }),
-    });
-    const pm = new ProjectManager(client, logger);
-    const res = await pm.listProjects({ pagination: { page: 3, pageSize: 1 } });
-    expect(res.pagination.totalPages).toBe(3);
-    expect(res.pagination.hasNext).toBe(false);
-    expect(res.pagination.hasPrevious).toBe(true);
-
-    const clientEmpty = makeClient({ getAllProjects: async () => ({ data: { project: [] } }) });
-    const pm2 = new ProjectManager(clientEmpty, logger);
-    const res2 = await pm2.listProjects({ pagination: { page: 1, pageSize: 5 } });
-    expect(res2.pagination.totalCount).toBe(0);
-    expect(res2.pagination.hasNext).toBe(false);
-    expect(res2.pagination.hasPrevious).toBe(false);
-  });
-
-  it('getProjectDescendants respects maxDepth boundary', async () => {
-    const client = makeClient({
-      getAllSubprojectsOrdered: async (id: string) => {
-        if (id === '_Root') return { data: { project: [{ id: 'A', name: 'A' }] } };
-        if (id === 'A') return { data: { project: [{ id: 'A1', name: 'A1' }] } };
-        return { data: { project: [] } };
-      },
-    });
-    const pm = new ProjectManager(client, logger);
-    const res = await pm.getProjectDescendants('_Root', 1);
-    // Current implementation allows collecting next level when depth equals maxDepth
-    expect(new Set(res.map((p) => p.id))).toEqual(new Set(['A', 'A1']));
-  });
-});

package/tests/unit/teamcity/project-manager-more.test.ts

@@ -1,90 +0,0 @@
-import type { Logger } from 'winston';
-
-import type { Project, Projects } from '@/teamcity-client/models';
-import { ProjectManager } from '@/teamcity/project-manager';
-
-const logger: Logger = { error: jest.fn() } as unknown as Logger;
-
-const makeClient = (
-  impl: Partial<{
-    getAllProjects: (locator?: string, fields?: string) => Promise<{ data: Projects }>;
-    getProject: (id: string, fields?: string) => Promise<{ data: Project }>;
-    getAllSubprojectsOrdered: (id: string, fields?: string) => Promise<{ data: Projects }>;
-  }>
-) => {
-  return {
-    projects: {
-      getAllProjects: impl.getAllProjects ?? (async () => ({ data: { project: [] } as Projects })),
-      getProject:
-        impl.getProject ??
-        (async (id: string) => ({ data: { id, name: id } as unknown as Project })),
-      getAllSubprojectsOrdered:
-        impl.getAllSubprojectsOrdered ?? (async () => ({ data: { project: [] } as Projects })),
-    },
-  } as unknown as import('@/teamcity/client').TeamCityClient;
-};
-
-describe('ProjectManager (more branches)', () => {
-  it('listProjects without filters builds no locator and no stats fields', async () => {
-    const calls: { locator?: string; fields?: string }[] = [];
-    const client = makeClient({
-      getAllProjects: async (locator?: string, fields?: string) => {
-        calls.push({ locator, fields });
-        return { data: { project: [{ id: 'X', name: 'X' }] } as unknown as Projects };
-      },
-    });
-    const pm = new ProjectManager(client, logger);
-    const res = await pm.listProjects();
-    // Behavior-first: avoid verifying internal fields/locator; assert result shape only
-    expect(res.projects[0]?.id).toBe('X');
-  });
-
-  it('getProject returns null on 404', async () => {
-    const client = makeClient({
-      getProject: async (_: string) => {
-        const err = Object.assign(new Error('Not found'), { response: { status: 404 } });
-        throw err;
-      },
-    });
-    const pm = new ProjectManager(client, logger);
-    const res = await (pm as unknown as { getProject: (id: string) => Promise<null> }).getProject(
-      'NOPE'
-    );
-    expect(res).toBeNull();
-  });
-
-  it('applyFilters handles hasBuilds=false and maxDepth', async () => {
-    const client = makeClient({});
-    const pm = new ProjectManager(client, logger);
-    const projects: Array<{ id: string; name: string; buildTypesCount?: number; level?: number }> =
-      [
-        { id: 'A', name: 'A', buildTypesCount: 0, level: 2 },
-        { id: 'B', name: 'B', buildTypesCount: 2, level: 3 },
-      ];
-    const filtered = (
-      pm as unknown as {
-        applyFilters: (
-          p: Array<{ id: string; name: string; buildTypesCount?: number; level?: number }>,
-          f: { hasBuilds?: boolean; maxDepth?: number }
-        ) => Array<{ id: string }>;
-      }
-    ).applyFilters(projects, { hasBuilds: false, maxDepth: 2 });
-    expect(filtered.map((p) => p.id)).toEqual(['A']);
-  });
-
-  it('paginate computes hasNext/hasPrevious correctly', async () => {
-    const client = makeClient({});
-    const pm = new ProjectManager(client, logger);
-    const projects = Array.from({ length: 3 }, (_, i) => ({ id: String(i), name: String(i) }));
-    const page2 = (
-      pm as unknown as {
-        paginate: (
-          p: Array<{ id: string; name: string }>,
-          pg: { page?: number; pageSize?: number }
-        ) => { pagination: { hasNext: boolean; hasPrevious: boolean } };
-      }
-    ).paginate(projects, { page: 2, pageSize: 2 });
-    expect(page2.pagination.hasPrevious).toBe(true);
-    expect(page2.pagination.hasNext).toBe(false);
-  });
-});

package/tests/unit/teamcity/project-manager.test.ts

@@ -1,189 +0,0 @@
-import type { Logger } from 'winston';
-
-import type { Project, Projects } from '@/teamcity-client/models';
-import { ProjectManager } from '@/teamcity/project-manager';
-
-describe('ProjectManager', () => {
-  const logger: Logger = { error: jest.fn() } as unknown as Logger;
-
-  const makeClient = (
-    impl: Partial<{
-      getAllProjects: (locator?: string, fields?: string) => Promise<{ data: Projects }>;
-      getProject: (id: string, fields?: string) => Promise<{ data: Project }>;
-      getAllSubprojectsOrdered: (id: string, fields?: string) => Promise<{ data: Projects }>;
-    }>
-  ) => {
-    return {
-      projects: {
-        getAllProjects:
-          impl.getAllProjects ?? (async () => ({ data: { project: [] } as Projects })),
-        getProject:
-          impl.getProject ??
-          (async (id: string) => ({ data: { id, name: id } as unknown as Project })),
-        getAllSubprojectsOrdered:
-          impl.getAllSubprojectsOrdered ?? (async () => ({ data: { project: [] } as Projects })),
-      },
-    } as unknown as import('@/teamcity/client').TeamCityClient;
-  };
-
-  it('lists, filters, sorts and paginates projects', async () => {
-    const projects: Projects = {
-      project: [
-        {
-          id: 'B',
-          name: 'Beta',
-          archived: false,
-          buildTypes: { count: 0 },
-        } as unknown as Project,
-        {
-          id: 'A',
-          name: 'Alpha',
-          archived: true,
-          buildTypes: { count: 2 },
-          parameters: { property: [{ name: 'k', value: 'v' }] },
-          projects: { count: 1 },
-        } as unknown as Project,
-      ],
-    };
-
-    const captured: { locator?: string; fields?: string }[] = [];
-    const client = makeClient({
-      getAllProjects: async (locator?: string, fields?: string) => {
-        captured.push({ locator, fields });
-        return { data: projects };
-      },
-    });
-
-    const pm = new ProjectManager(client, logger);
-    const res = await pm.listProjects({
-      filters: { archived: true, parentProjectId: 'PARENT', namePattern: 'A*', hasBuilds: true },
-      sort: { by: 'id', order: 'desc' },
-      pagination: { page: 1, pageSize: 1 },
-      includeStatistics: true,
-    });
-
-    // Behavior-first: avoid verifying internal locator/fields construction
-
-    // After filters (name A* and hasBuilds true), only project A remains
-    expect(res.projects.length).toBe(1);
-    const first = res.projects[0];
-    expect(first?.id).toBe('A');
-    expect(first?.parameters).toEqual({ k: 'v' });
-    expect(res.pagination.totalCount).toBe(1);
-  });
-
-  it('getProjectHierarchy builds structure and tracks levels and paths', async () => {
-    const client = makeClient({
-      getProject: async (id: string) => ({ data: { id, name: id } as unknown as Project }),
-      getAllSubprojectsOrdered: async (id: string) => ({
-        data: {
-          project: id === '_Root' ? ([{ id: 'A' }] as unknown as Project[]) : [],
-        } as Projects,
-      }),
-    });
-
-    const pm = new ProjectManager(client, logger);
-    const root = await pm.getProjectHierarchy('_Root', 5);
-    expect(root.project.id).toBe('_Root');
-    const child0 = root.children[0];
-    expect(child0?.project.id).toBe('A');
-    expect(child0?.project.level).toBe(1);
-    expect(child0?.project.path).toEqual(['_Root', 'A']);
-  });
-
-  it('getProjectHierarchy throws on circular reference', async () => {
-    const client = makeClient({
-      getProject: async (id: string) => ({ data: { id, name: id } as unknown as Project }),
-      getAllSubprojectsOrdered: async (id: string) => ({
-        data: { project: [{ id }] as unknown as Project[] } as Projects, // child points to itself
-      }),
-    });
-
-    const pm = new ProjectManager(client, logger);
-    await expect(pm.getProjectHierarchy('_Root', 5)).rejects.toThrow(/Circular reference/);
-  });
-
-  it('getProjectAncestors builds chain up to _Root', async () => {
-    const chain: Record<string, Project> = {
-      C: { id: 'C', name: 'C', parentProjectId: 'B' } as unknown as Project,
-      B: { id: 'B', name: 'B', parentProjectId: '_Root' } as unknown as Project,
-    };
-    const client = makeClient({
-      getProject: async (id: string) => ({ data: chain[id] ?? ({ id } as unknown as Project) }),
-    });
-    const pm = new ProjectManager(client, logger);
-    const ancestors = await pm.getProjectAncestors('C');
-    expect(ancestors.map((p) => p.id)).toEqual(['B', 'C']);
-  });
-
-  it('getProjectDescendants collects normalized descendants with levels', async () => {
-    const sub: Record<string, Projects> = {
-      _Root: { project: [{ id: 'A', name: 'A' } as unknown as Project] },
-      A: { project: [{ id: 'A1', name: 'A1' } as unknown as Project] },
-      A1: { project: [] },
-    };
-    const client = makeClient({
-      getAllSubprojectsOrdered: async (id: string) => ({ data: sub[id] ?? { project: [] } }),
-    });
-    const pm = new ProjectManager(client, logger);
-    const descendants = await pm.getProjectDescendants('_Root', 5);
-    const ids = descendants.map((d) => d.id);
-    expect(ids).toEqual(['A', 'A1']);
-    expect(descendants.find((d) => d.id === 'A')?.level).toBe(1);
-    expect(descendants.find((d) => d.id === 'A1')?.level).toBe(2);
-  });
-
-  it('listProjects logs and rethrows on API error', async () => {
-    const client = makeClient({
-      getAllProjects: async () => {
-        throw new Error('boom');
-      },
-    });
-    const logger: Logger = { error: jest.fn() } as unknown as Logger;
-    const pm = new ProjectManager(client, logger);
-    await expect(pm.listProjects()).rejects.toThrow('boom');
-    expect((logger.error as jest.Mock).mock.calls[0]?.[0]).toMatch(/Failed to list projects/);
-  });
-
-  it('getProjectHierarchy logs and rethrows on project error', async () => {
-    const client = makeClient({
-      getProject: async () => {
-        throw new Error('nope');
-      },
-    });
-    const logger: Logger = { error: jest.fn() } as unknown as Logger;
-    const pm = new ProjectManager(client, logger);
-    await expect(pm.getProjectHierarchy('_Root', 2)).rejects.toThrow('nope');
-    expect((logger.error as jest.Mock).mock.calls[0]?.[0]).toMatch(
-      /Failed to get project hierarchy/
-    );
-  });
-
-  it('sortProjects by id and level with desc order', async () => {
-    const client = makeClient({});
-    const pm = new ProjectManager(client, { error: jest.fn() } as unknown as Logger);
-    const projects: Array<{ id: string; name: string; level?: number }> = [
-      { id: 'B', name: 'B', level: 1 },
-      { id: 'A', name: 'A', level: 2 },
-      { id: 'C', name: 'C', level: 0 },
-    ];
-    const byIdDesc = (
-      pm as unknown as {
-        sortProjects: (
-          p: Array<{ id: string; name: string; level?: number }>,
-          s: { by?: 'name' | 'id' | 'level'; order?: 'asc' | 'desc' }
-        ) => Array<{ id: string; name: string; level?: number }>;
-      }
-    ).sortProjects(projects, { by: 'id', order: 'desc' });
-    expect(byIdDesc.map((p) => p.id)).toEqual(['C', 'B', 'A']);
-    const byLevelDesc = (
-      pm as unknown as {
-        sortProjects: (
-          p: Array<{ id: string; name: string; level?: number }>,
-          s: { by?: 'name' | 'id' | 'level'; order?: 'asc' | 'desc' }
-        ) => Array<{ id: string; name: string; level?: number }>;
-      }
-    ).sortProjects(projects, { by: 'level', order: 'desc' });
-    expect(byLevelDesc.map((p) => p.level)).toEqual([2, 1, 0]);
-  });
-});