@dpesch/mantisbt-mcp-server 1.10.2 → 1.10.6

package/scripts/init.mjs

@@ -1,95 +0,0 @@
-#!/usr/bin/env node
-// Project setup script — run via: npm run init
-//
-// Steps:
-//   1. Check Node.js version (requires >=18)
-//   2. Install dependencies (npm install)
-//   3. Install git hooks from scripts/hooks/ into .git/hooks/
-//   4. Run typecheck to verify the setup
-
-import { spawnSync } from 'node:child_process';
-import { copyFileSync, chmodSync, existsSync, mkdirSync } from 'node:fs';
-import { resolve, dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-// Auf Windows .cmd-Dateien via cmd.exe aufrufen — kein shell:true nötig, keine Deprecation-Warnung
-const [npmBin, npmBaseArgs] = process.platform === 'win32'
-  ? ['cmd.exe', ['/c', 'npm']]
-  : ['npm', []];
-
-// ---------------------------------------------------------------------------
-// 1. Node.js version check
-// ---------------------------------------------------------------------------
-
-const [major] = process.versions.node.split('.').map(Number);
-if (major < 18) {
-  console.error(`✗ Node.js >= 18 required, found ${process.version}`);
-  process.exit(1);
-}
-console.log(`✓ Node.js ${process.version}`);
-
-// ---------------------------------------------------------------------------
-// 2. Install dependencies
-// ---------------------------------------------------------------------------
-
-console.log('\n→ Installing dependencies...');
-const install = spawnSync(npmBin, [...npmBaseArgs, 'install'], {
-  stdio: 'inherit',
-  cwd: root,
-});
-if (install.status !== 0) {
-  console.error('✗ npm install failed');
-  process.exit(1);
-}
-
-// ---------------------------------------------------------------------------
-// 3. Install git hooks
-// ---------------------------------------------------------------------------
-
-console.log('\n→ Installing git hooks...');
-
-const hooksSourceDir = resolve(root, 'scripts/hooks');
-const gitHooksDir = resolve(root, '.git/hooks');
-
-if (!existsSync(gitHooksDir)) {
-  mkdirSync(gitHooksDir, { recursive: true });
-}
-
-const hooks = ['pre-push'];
-for (const hook of hooks) {
-  const src = resolve(hooksSourceDir, `${hook}.mjs`);
-  const dest = resolve(gitHooksDir, hook);
-
-  if (!existsSync(src)) {
-    console.warn(`  ⚠ Hook source not found, skipping: scripts/hooks/${hook}.mjs`);
-    continue;
-  }
-
-  copyFileSync(src, dest);
-
-  // chmod +x (no-op on Windows — git runs hooks directly via shebang)
-  try {
-    chmodSync(dest, 0o755);
-  } catch {
-    // Silently ignore on platforms that don't support chmod
-  }
-
-  console.log(`  ✓ .git/hooks/${hook} installed`);
-}
-
-// ---------------------------------------------------------------------------
-// 4. Typecheck
-// ---------------------------------------------------------------------------
-
-console.log('\n→ Running typecheck...');
-const check = spawnSync(npmBin, [...npmBaseArgs, 'run', 'typecheck'], {
-  stdio: 'inherit',
-  cwd: root,
-});
-if (check.status !== 0) {
-  console.error('✗ Typecheck failed — check type errors above');
-  process.exit(1);
-}
-
-console.log('\n✓ Setup complete. Happy hacking!');

package/scripts/record-fixtures.ts

@@ -1,160 +0,0 @@
-import { writeFileSync, mkdirSync, readFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { MantisClient } from '../src/client.js';
-import { ISSUE_ENUM_OPTIONS } from '../src/constants.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// ---------------------------------------------------------------------------
-// .env.local laden (falls vorhanden)
-// ---------------------------------------------------------------------------
-
-try {
-  const envPath = join(__dirname, '..', '.env.local');
-  const lines = readFileSync(envPath, 'utf-8').split('\n');
-  for (const line of lines) {
-    const match = line.match(/^([^#=\s][^=]*)=(.*)$/);
-    if (match) {
-      const key = match[1].trim();
-      const value = match[2].trim().replace(/^["']|["']$/g, '');
-      if (!process.env[key]) process.env[key] = value;
-    }
-  }
-} catch {
-  // .env.local nicht vorhanden – ENV-Vars direkt nutzen
-}
-
-// ---------------------------------------------------------------------------
-// Config aus ENV
-// ---------------------------------------------------------------------------
-
-const baseUrlRaw = process.env['MANTIS_BASE_URL'];
-const apiKey = process.env['MANTIS_API_KEY'];
-
-if (!baseUrlRaw || !apiKey) {
-  console.error('Error: MANTIS_BASE_URL and MANTIS_API_KEY environment variables must be set.');
-  process.exit(1);
-}
-
-const baseUrl = baseUrlRaw.replace(/\/$/, '');
-
-// ---------------------------------------------------------------------------
-// Fixtures-Verzeichnis
-// ---------------------------------------------------------------------------
-
-const fixturesDir = join(__dirname, '..', 'tests', 'fixtures', 'recorded');
-mkdirSync(fixturesDir, { recursive: true });
-
-function saveFixture(filename: string, data: unknown): void {
-  const filePath = join(fixturesDir, filename);
-  writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
-  console.log(`Saved: ${filePath}`);
-}
-
-// ---------------------------------------------------------------------------
-// Client instanziieren
-// ---------------------------------------------------------------------------
-
-const client = new MantisClient(baseUrl, apiKey);
-
-// ---------------------------------------------------------------------------
-// Fixtures aufzeichnen
-// ---------------------------------------------------------------------------
-
-async function recordFixtures(): Promise<void> {
-  // GET projects
-  let firstProjectId: number | undefined;
-  let projectIdWithVersions: number | undefined;
-  try {
-    const projectsResult = await client.get<{ projects: Array<{ id: number; name: string; versions?: unknown[] }> }>('projects');
-    saveFixture('list_projects.json', projectsResult);
-    if (Array.isArray(projectsResult.projects) && projectsResult.projects.length > 0) {
-      firstProjectId = projectsResult.projects[0]?.id;
-      // Erstes Projekt mit nicht-leeren Versionen bevorzugen
-      projectIdWithVersions = projectsResult.projects.find(
-        (p) => Array.isArray(p.versions) && p.versions.length > 0,
-      )?.id ?? firstProjectId;
-    }
-  } catch (err) {
-    console.error('Failed to fetch projects:', err instanceof Error ? err.message : String(err));
-  }
-
-  // GET users/me
-  try {
-    const userResult = await client.get<unknown>('users/me');
-    saveFixture('get_current_user.json', userResult);
-  } catch (err) {
-    console.error('Failed to fetch users/me:', err instanceof Error ? err.message : String(err));
-  }
-
-  // GET issues?page=1&page_size=3
-  let firstIssueId: number | undefined;
-  try {
-    const issuesResult = await client.get<{ issues: Array<{ id: number }> }>('issues', {
-      page: 1,
-      page_size: 3,
-    });
-    saveFixture('list_issues.json', issuesResult);
-    if (Array.isArray(issuesResult.issues) && issuesResult.issues.length > 0) {
-      firstIssueId = issuesResult.issues[0]?.id;
-    }
-  } catch (err) {
-    console.error('Failed to fetch issues:', err instanceof Error ? err.message : String(err));
-  }
-
-  // GET issues?page=1&page_size=1 — single issue sample for get_issue_fields field discovery
-  try {
-    const sampleResult = await client.get<{ issues: unknown[] }>('issues', {
-      page: 1,
-      page_size: 1,
-    });
-    saveFixture('get_issue_fields_sample.json', sampleResult);
-  } catch (err) {
-    console.error('Failed to fetch issues sample:', err instanceof Error ? err.message : String(err));
-  }
-
-  // GET issues/{id}
-  if (firstIssueId !== undefined) {
-    try {
-      const issueResult = await client.get<unknown>(`issues/${firstIssueId}`);
-      saveFixture('get_issue.json', issueResult);
-    } catch (err) {
-      console.error(`Failed to fetch issues/${firstIssueId}:`, err instanceof Error ? err.message : String(err));
-    }
-  }
-
-  // GET config — enum values for severity, status, priority, resolution, reproducibility
-  try {
-    const enumParams: Record<string, string> = {};
-    ISSUE_ENUM_OPTIONS.forEach((opt, i) => { enumParams[`option[${i}]`] = opt; });
-    const configResult = await client.get<unknown>('config', enumParams);
-    saveFixture('get_issue_enums.json', configResult);
-  } catch (err) {
-    console.error('Failed to fetch config enums:', err instanceof Error ? err.message : String(err));
-  }
-
-  // GET projects/{id}/versions + categories
-  if (firstProjectId !== undefined) {
-    const versionProjectId = projectIdWithVersions ?? firstProjectId;
-    try {
-      const versionsResult = await client.get<unknown>(`projects/${versionProjectId}/versions`, { obsolete: 1, inherit: 1 });
-      saveFixture('get_project_versions.json', versionsResult);
-    } catch (err) {
-      console.error(`Failed to fetch projects/${versionProjectId}/versions:`, err instanceof Error ? err.message : String(err));
-    }
-
-    try {
-      const projectResult = await client.get<{ projects: Array<{ categories?: unknown[] }> }>(`projects/${firstProjectId}`);
-      saveFixture('get_project_categories.json', { categories: projectResult.projects?.[0]?.categories ?? [] });
-    } catch (err) {
-      console.error(`Failed to fetch projects/${firstProjectId} (categories):`, err instanceof Error ? err.message : String(err));
-    }
-  }
-}
-
-recordFixtures().catch((err) => {
-  console.error('Unexpected error:', err);
-  process.exit(1);
-});

package/tests/cache.test.ts

@@ -1,265 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-// vi.mock must be at module top level — vitest hoists it automatically
-vi.mock('node:fs/promises');
-
-import { readFile, writeFile, unlink, mkdir } from 'node:fs/promises';
-import { MetadataCache, type CachedMetadata } from '../src/cache.js';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-const CACHE_DIR = '/tmp/test-cache';
-const TTL = 3600; // 1 hour in seconds
-
-function makeCache(): MetadataCache {
-  return new MetadataCache(CACHE_DIR, TTL);
-}
-
-function makeSampleMetadata(): CachedMetadata {
-  return {
-    timestamp: Date.now(),
-    projects: [{ id: 1, name: 'Test Project' }],
-    byProject: {},
-    tags: [],
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Setup
-// ---------------------------------------------------------------------------
-
-beforeEach(() => {
-  vi.resetAllMocks();
-});
-
-// ---------------------------------------------------------------------------
-// isValid()
-// ---------------------------------------------------------------------------
-
-describe('MetadataCache – isValid()', () => {
-  it('returns false when file does not exist (readFile throws)', async () => {
-    vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
-
-    const cache = makeCache();
-    await expect(cache.isValid()).resolves.toBe(false);
-  });
-
-  it('returns true when file is fresh (within TTL)', async () => {
-    const file = { timestamp: Date.now(), data: makeSampleMetadata() };
-    vi.mocked(readFile).mockResolvedValue(JSON.stringify(file) as any);
-
-    const cache = makeCache();
-    await expect(cache.isValid()).resolves.toBe(true);
-  });
-
-  it('returns false when file has expired (timestamp older than TTL)', async () => {
-    const expiredTimestamp = Date.now() - (TTL + 1) * 1000;
-    const file = { timestamp: expiredTimestamp, data: makeSampleMetadata() };
-    vi.mocked(readFile).mockResolvedValue(JSON.stringify(file) as any);
-
-    const cache = makeCache();
-    await expect(cache.isValid()).resolves.toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// load()
-// ---------------------------------------------------------------------------
-
-describe('MetadataCache – load()', () => {
-  it('returns null when file does not exist', async () => {
-    vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
-
-    const cache = makeCache();
-    await expect(cache.load()).resolves.toBeNull();
-  });
-
-  it('returns CachedMetadata when file exists', async () => {
-    const metadata = makeSampleMetadata();
-    const file = { timestamp: Date.now(), data: metadata };
-    vi.mocked(readFile).mockResolvedValue(JSON.stringify(file) as any);
-
-    const cache = makeCache();
-    const result = await cache.load();
-    expect(result).toEqual(metadata);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// save()
-// ---------------------------------------------------------------------------
-
-describe('MetadataCache – save()', () => {
-  it('calls mkdir with recursive:true and writeFile with JSON content', async () => {
-    vi.mocked(mkdir).mockResolvedValue(undefined);
-    vi.mocked(writeFile).mockResolvedValue(undefined);
-
-    const cache = makeCache();
-    const metadata = makeSampleMetadata();
-    await cache.save(metadata);
-
-    expect(mkdir).toHaveBeenCalledWith(CACHE_DIR, { recursive: true });
-    expect(writeFile).toHaveBeenCalledOnce();
-
-    // Verify the written JSON contains our data
-    const writtenContent = vi.mocked(writeFile).mock.calls[0][1] as string;
-    const parsed = JSON.parse(writtenContent) as { timestamp: number; data: CachedMetadata };
-    expect(parsed.data).toEqual(metadata);
-  });
-
-  it('writes a timestamp to the cache file', async () => {
-    vi.mocked(mkdir).mockResolvedValue(undefined);
-    vi.mocked(writeFile).mockResolvedValue(undefined);
-
-    const before = Date.now();
-    const cache = makeCache();
-    await cache.save(makeSampleMetadata());
-    const after = Date.now();
-
-    const writtenContent = vi.mocked(writeFile).mock.calls[0][1] as string;
-    const parsed = JSON.parse(writtenContent) as { timestamp: number };
-    expect(parsed.timestamp).toBeGreaterThanOrEqual(before);
-    expect(parsed.timestamp).toBeLessThanOrEqual(after);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// invalidate()
-// ---------------------------------------------------------------------------
-
-describe('MetadataCache – invalidate()', () => {
-  it('calls unlink on the cache file', async () => {
-    vi.mocked(unlink).mockResolvedValue(undefined);
-
-    const cache = makeCache();
-    await cache.invalidate();
-
-    expect(unlink).toHaveBeenCalledOnce();
-    const calledPath = vi.mocked(unlink).mock.calls[0][0] as string;
-    expect(calledPath).toContain('metadata.json');
-  });
-
-  it('does not throw when file does not exist (unlink rejects)', async () => {
-    vi.mocked(unlink).mockRejectedValue(new Error('ENOENT'));
-
-    const cache = makeCache();
-    await expect(cache.invalidate()).resolves.toBeUndefined();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// loadIfValid()
-// ---------------------------------------------------------------------------
-
-describe('MetadataCache – loadIfValid()', () => {
-  it('returns null when file does not exist', async () => {
-    vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
-
-    const cache = makeCache();
-    await expect(cache.loadIfValid()).resolves.toBeNull();
-  });
-
-  it('returns data when file is fresh (within TTL)', async () => {
-    const metadata = makeSampleMetadata();
-    const file = { timestamp: Date.now(), data: metadata };
-    vi.mocked(readFile).mockResolvedValue(JSON.stringify(file) as any);
-
-    const cache = makeCache();
-    const result = await cache.loadIfValid();
-    expect(result).toEqual(metadata);
-  });
-
-  it('returns null when file has expired', async () => {
-    const expiredTimestamp = Date.now() - (TTL + 1) * 1000;
-    const metadata = makeSampleMetadata();
-    const file = { timestamp: expiredTimestamp, data: metadata };
-    vi.mocked(readFile).mockResolvedValue(JSON.stringify(file) as any);
-
-    const cache = makeCache();
-    await expect(cache.loadIfValid()).resolves.toBeNull();
-  });
-
-  it('reads from metadata.json path', async () => {
-    vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
-
-    const cache = makeCache();
-    await cache.loadIfValid();
-
-    expect(readFile).toHaveBeenCalledOnce();
-    const calledPath = vi.mocked(readFile).mock.calls[0][0] as string;
-    expect(calledPath).toContain('metadata.json');
-    expect(calledPath).not.toContain('issue_fields.json');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// loadIssueFields()
-// ---------------------------------------------------------------------------
-
-describe('MetadataCache – loadIssueFields()', () => {
-  it('returns null when file does not exist', async () => {
-    vi.mocked(readFile).mockRejectedValue(new Error('ENOENT'));
-
-    const cache = makeCache();
-    await expect(cache.loadIssueFields()).resolves.toBeNull();
-  });
-
-  it('returns fields array when file is fresh', async () => {
-    const fields = ['id', 'summary', 'status'];
-    const file = { timestamp: Date.now(), fields };
-    vi.mocked(readFile).mockResolvedValue(JSON.stringify(file) as any);
-
-    const cache = makeCache();
-    const result = await cache.loadIssueFields();
-    expect(result).toEqual(fields);
-  });
-
-  it('returns null when file has expired', async () => {
-    const expiredTimestamp = Date.now() - (TTL + 1) * 1000;
-    const file = { timestamp: expiredTimestamp, fields: ['id', 'summary'] };
-    vi.mocked(readFile).mockResolvedValue(JSON.stringify(file) as any);
-
-    const cache = makeCache();
-    await expect(cache.loadIssueFields()).resolves.toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// saveIssueFields()
-// ---------------------------------------------------------------------------
-
-describe('MetadataCache – saveIssueFields()', () => {
-  it('calls mkdir with recursive:true and writes to issue_fields.json', async () => {
-    vi.mocked(mkdir).mockResolvedValue(undefined);
-    vi.mocked(writeFile).mockResolvedValue(undefined);
-
-    const cache = makeCache();
-    const fields = ['id', 'summary', 'status', 'priority'];
-    await cache.saveIssueFields(fields);
-
-    expect(mkdir).toHaveBeenCalledWith(CACHE_DIR, { recursive: true });
-    expect(writeFile).toHaveBeenCalledOnce();
-
-    const calledPath = vi.mocked(writeFile).mock.calls[0][0] as string;
-    expect(calledPath).toContain('issue_fields.json');
-  });
-
-  it('written JSON contains the fields array and a timestamp', async () => {
-    vi.mocked(mkdir).mockResolvedValue(undefined);
-    vi.mocked(writeFile).mockResolvedValue(undefined);
-
-    const cache = makeCache();
-    const fields = ['id', 'summary', 'status'];
-    const before = Date.now();
-    await cache.saveIssueFields(fields);
-    const after = Date.now();
-
-    const writtenContent = vi.mocked(writeFile).mock.calls[0][1] as string;
-    const parsed = JSON.parse(writtenContent) as { timestamp: number; fields: string[] };
-    expect(parsed.fields).toEqual(fields);
-    expect(parsed.timestamp).toBeGreaterThanOrEqual(before);
-    expect(parsed.timestamp).toBeLessThanOrEqual(after);
-  });
-});