@aaronshaf/ger 1.2.10 → 2.0.0

package/tests/vote.test.ts

@@ -0,0 +1,317 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, mock } from 'bun:test'
+import { Effect, Layer } from 'effect'
+import { HttpResponse, http } from 'msw'
+import { setupServer } from 'msw/node'
+import { GerritApiServiceLive } from '@/api/gerrit'
+import { voteCommand } from '@/cli/commands/vote'
+import { ConfigService } from '@/services/config'
+import { createMockConfigService } from './helpers/config-mock'
+
+// Create MSW server
+const server = setupServer(
+  // Default handler for auth check
+  http.get('*/a/accounts/self', ({ request }) => {
+    const auth = request.headers.get('Authorization')
+    if (!auth || !auth.startsWith('Basic ')) {
+      return HttpResponse.text('Unauthorized', { status: 401 })
+    }
+    return HttpResponse.json({
+      _account_id: 1000,
+      name: 'Test User',
+      email: 'test@example.com',
+    })
+  }),
+)
+
+describe('vote command', () => {
+  let mockConsoleLog: ReturnType<typeof mock>
+  let mockConsoleError: ReturnType<typeof mock>
+
+  beforeAll(() => {
+    server.listen({ onUnhandledRequest: 'bypass' })
+  })
+
+  afterAll(() => {
+    server.close()
+  })
+
+  beforeEach(() => {
+    mockConsoleLog = mock(() => {})
+    mockConsoleError = mock(() => {})
+    console.log = mockConsoleLog
+    console.error = mockConsoleError
+  })
+
+  afterEach(() => {
+    server.resetHandlers()
+  })
+
+  it('should vote with Code-Review only', async () => {
+    server.use(
+      http.post('*/a/changes/12345/revisions/current/review', async ({ request }) => {
+        const body = (await request.json()) as { labels?: Record<string, number>; message?: string }
+        expect(body.labels).toEqual({ 'Code-Review': 2 })
+        expect(body.message).toBeUndefined()
+        return HttpResponse.text(")]}'\n{}")
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = voteCommand('12345', {
+      codeReview: 2,
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('Voted on change 12345')
+    expect(output).toContain('Code-Review: +2')
+  })
+
+  it('should vote with Code-Review and Verified', async () => {
+    server.use(
+      http.post('*/a/changes/12345/revisions/current/review', async ({ request }) => {
+        const body = (await request.json()) as { labels?: Record<string, number>; message?: string }
+        expect(body.labels).toEqual({ 'Code-Review': 1, Verified: 1 })
+        return HttpResponse.text(")]}'\n{}")
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = voteCommand('12345', {
+      codeReview: 1,
+      verified: 1,
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('Code-Review: +1')
+    expect(output).toContain('Verified: +1')
+  })
+
+  it('should vote with negative values', async () => {
+    server.use(
+      http.post('*/a/changes/12345/revisions/current/review', async ({ request }) => {
+        const body = (await request.json()) as { labels?: Record<string, number>; message?: string }
+        expect(body.labels).toEqual({ 'Code-Review': -2, Verified: -1 })
+        return HttpResponse.text(")]}'\n{}")
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = voteCommand('12345', {
+      codeReview: -2,
+      verified: -1,
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('Code-Review: -2')
+    expect(output).toContain('Verified: -1')
+  })
+
+  it('should vote with message', async () => {
+    server.use(
+      http.post('*/a/changes/12345/revisions/current/review', async ({ request }) => {
+        const body = (await request.json()) as { labels?: Record<string, number>; message?: string }
+        expect(body.labels).toEqual({ 'Code-Review': 2 })
+        expect(body.message).toBe('Looks good to me!')
+        return HttpResponse.text(")]}'\n{}")
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = voteCommand('12345', {
+      codeReview: 2,
+      message: 'Looks good to me!',
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('Code-Review: +2')
+    expect(output).toContain('Message: Looks good to me!')
+  })
+
+  it('should vote with custom labels', async () => {
+    server.use(
+      http.post('*/a/changes/12345/revisions/current/review', async ({ request }) => {
+        const body = (await request.json()) as { labels?: Record<string, number>; message?: string }
+        expect(body.labels).toEqual({ 'Code-Review': 2, 'Custom-Label': 1 })
+        return HttpResponse.text(")]}'\n{}")
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = voteCommand('12345', {
+      codeReview: 2,
+      label: ['Custom-Label', '1'],
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('Code-Review: +2')
+    expect(output).toContain('Custom-Label: +1')
+  })
+
+  it('should vote with multiple custom labels', async () => {
+    server.use(
+      http.post('*/a/changes/12345/revisions/current/review', async ({ request }) => {
+        const body = (await request.json()) as { labels?: Record<string, number>; message?: string }
+        expect(body.labels).toEqual({ 'Label-A': 1, 'Label-B': -1 })
+        return HttpResponse.text(")]}'\n{}")
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = voteCommand('12345', {
+      label: ['Label-A', '1', 'Label-B', '-1'],
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('Label-A: +1')
+    expect(output).toContain('Label-B: -1')
+  })
+
+  it('should output XML format when --xml flag is used', async () => {
+    server.use(
+      http.post('*/a/changes/12345/revisions/current/review', async ({ request }) => {
+        const body = (await request.json()) as { labels?: Record<string, number>; message?: string }
+        expect(body.labels).toEqual({ 'Code-Review': 2, Verified: 1 })
+        expect(body.message).toBe('LGTM')
+        return HttpResponse.text(")]}'\n{}")
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = voteCommand('12345', {
+      xml: true,
+      codeReview: 2,
+      verified: 1,
+      message: 'LGTM',
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('<?xml version="1.0" encoding="UTF-8"?>')
+    expect(output).toContain('<vote_result>')
+    expect(output).toContain('<status>success</status>')
+    expect(output).toContain('<change_id>12345</change_id>')
+    expect(output).toContain('<label name="Code-Review">2</label>')
+    expect(output).toContain('<label name="Verified">1</label>')
+    expect(output).toContain('<message><![CDATA[LGTM]]></message>')
+    expect(output).toContain('</vote_result>')
+  })
+
+  it('should output XML format without message when no message provided', async () => {
+    server.use(
+      http.post('*/a/changes/12345/revisions/current/review', async () => {
+        return HttpResponse.text(")]}'\n{}")
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = voteCommand('12345', {
+      xml: true,
+      codeReview: 1,
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    await Effect.runPromise(program)
+
+    const output = mockConsoleLog.mock.calls.map((call) => call[0]).join('\n')
+    expect(output).toContain('<vote_result>')
+    expect(output).toContain('<status>success</status>')
+    expect(output).not.toContain('<message>')
+  })
+
+  it('should show error when change ID is not provided', async () => {
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = voteCommand(undefined, { codeReview: 2 }).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const errorOutput = mockConsoleError.mock.calls.map((call) => call[0]).join('\n')
+    expect(errorOutput).toContain('Change ID is required')
+    expect(errorOutput).toContain('Usage: ger vote <change-id>')
+  })
+
+  it('should show error when no labels are provided', async () => {
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = voteCommand('12345', {}).pipe(
+      Effect.provide(GerritApiServiceLive),
+      Effect.provide(mockConfigLayer),
+    )
+
+    await Effect.runPromise(program)
+
+    const errorOutput = mockConsoleError.mock.calls.map((call) => call[0]).join('\n')
+    expect(errorOutput).toContain('At least one label is required')
+  })
+
+  it('should handle vote API failure', async () => {
+    server.use(
+      http.post('*/a/changes/12345/revisions/current/review', () => {
+        return HttpResponse.text('Forbidden', { status: 403 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = voteCommand('12345', {
+      codeReview: 2,
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    // Should throw/fail
+    await expect(Effect.runPromise(program)).rejects.toThrow()
+  })
+
+  it('should handle not found errors gracefully', async () => {
+    server.use(
+      http.post('*/a/changes/99999/revisions/current/review', () => {
+        return HttpResponse.text('Change not found', { status: 404 })
+      }),
+    )
+
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = voteCommand('99999', {
+      codeReview: 2,
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    // Should fail when change is not found
+    await expect(Effect.runPromise(program)).rejects.toThrow()
+  })
+
+  it('should reject invalid custom label value', async () => {
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = voteCommand('12345', {
+      label: ['Custom-Label', 'not-a-number'],
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    await Effect.runPromise(program)
+
+    const errorOutput = mockConsoleError.mock.calls.map((call) => call[0]).join('\n')
+    expect(errorOutput).toContain('Invalid label value')
+    expect(errorOutput).toContain('Label values must be integers')
+  })
+
+  it('should reject odd number of label arguments', async () => {
+    const mockConfigLayer = Layer.succeed(ConfigService, createMockConfigService())
+    const program = voteCommand('12345', {
+      label: ['Custom-Label', '1', 'Another-Label'],
+    }).pipe(Effect.provide(GerritApiServiceLive), Effect.provide(mockConfigLayer))
+
+    await Effect.runPromise(program)
+
+    const errorOutput = mockConsoleError.mock.calls.map((call) => call[0]).join('\n')
+    expect(errorOutput).toContain('Invalid label format')
+    expect(errorOutput).toContain('name-value pairs')
+  })
+})

package/tests/workspace.test.ts

@@ -0,0 +1,295 @@
+import { describe, test, expect, mock, beforeEach, afterEach } from 'bun:test'
+
+// Mock external dependencies
+const mockFs = {
+  existsSync: mock(() => false),
+  mkdirSync: mock(),
+}
+
+const mockExecSync = mock()
+const mockSpawnSync = mock()
+
+const mockConsole = {
+  log: mock(),
+  error: mock(),
+}
+
+// Mock modules
+mock.module('node:fs', () => mockFs)
+mock.module('node:child_process', () => ({
+  execSync: mockExecSync,
+  spawnSync: mockSpawnSync,
+}))
+
+// Mock global console
+global.console = mockConsole as any
+
+describe('Workspace Command', () => {
+  beforeEach(() => {
+    // Reset all mocks
+    Object.values(mockFs).forEach((mock) => mock.mockReset())
+    mockExecSync.mockReset()
+    mockSpawnSync.mockReset()
+    mockConsole.log.mockReset()
+    mockConsole.error.mockReset()
+
+    // Set default mock behaviors
+    mockFs.existsSync.mockReturnValue(false)
+    mockExecSync.mockImplementation((command: string) => {
+      if (command === 'git rev-parse --git-dir') {
+        return '.git'
+      }
+      if (command === 'git rev-parse --show-toplevel') {
+        return '/repo/root'
+      }
+      if (command === 'git remote -v') {
+        return 'origin\thttps://gerrit.example.com/project\t(fetch)\n'
+      }
+      return ''
+    })
+    mockSpawnSync.mockReturnValue({ status: 0, stderr: '' })
+  })
+
+  afterEach(() => {
+    mock.restore()
+  })
+
+  describe('git repository validation', () => {
+    test('should detect git repository', () => {
+      mockExecSync.mockReturnValue('.git')
+
+      const result = mockExecSync('git rev-parse --git-dir')
+      expect(result).toBe('.git')
+    })
+
+    test('should handle non-git directory', () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('Not a git repository')
+      })
+
+      expect(() => {
+        mockExecSync('git rev-parse --git-dir')
+      }).toThrow('Not a git repository')
+    })
+
+    test('should find repository root', () => {
+      mockExecSync.mockReturnValue('/custom/repo/path')
+
+      const result = mockExecSync('git rev-parse --show-toplevel')
+      expect(result).toBe('/custom/repo/path')
+    })
+  })
+
+  describe('change specification parsing', () => {
+    test('should parse numeric change ID', () => {
+      const changeSpec = '12345'
+      const parts = changeSpec.split(':')
+
+      expect(parts[0]).toBe('12345')
+      expect(parts[1]).toBeUndefined()
+    })
+
+    test('should parse change ID with patchset', () => {
+      const changeSpec = '12345:3'
+      const parts = changeSpec.split(':')
+
+      expect(parts[0]).toBe('12345')
+      expect(parts[1]).toBe('3')
+    })
+
+    test('should handle Change-Id format', () => {
+      const changeId = 'I1234567890abcdef1234567890abcdef12345678'
+      expect(changeId.startsWith('I')).toBe(true)
+      expect(changeId.length).toBe(41)
+    })
+  })
+
+  describe('remote matching', () => {
+    test('should parse git remotes output', () => {
+      const remoteOutput = 'origin\thttps://gerrit.example.com/project\t(fetch)\n'
+      const lines = remoteOutput.split('\n')
+      const match = lines[0].match(/^(\S+)\s+(\S+)\s+\(fetch\)$/)
+
+      expect(match).toBeDefined()
+      expect(match?.[1]).toBe('origin')
+      expect(match?.[2]).toBe('https://gerrit.example.com/project')
+    })
+
+    test('should match HTTP URLs', () => {
+      const gerritHost = 'https://gerrit.example.com'
+      const remoteUrl = 'https://gerrit.example.com/project'
+
+      const gerritHostname = new URL(gerritHost).hostname
+      const remoteHostname = new URL(remoteUrl).hostname
+
+      expect(gerritHostname).toBe(remoteHostname)
+    })
+
+    test('should match SSH URLs', () => {
+      const gerritHost = 'https://gerrit.example.com'
+      const sshUrl = 'git@gerrit.example.com:project'
+
+      const gerritHostname = new URL(gerritHost).hostname
+      const sshHostname = sshUrl.split('@')[1].split(':')[0]
+
+      expect(gerritHostname).toBe(sshHostname)
+    })
+  })
+
+  describe('workspace directory management', () => {
+    test('should check if directory exists', () => {
+      mockFs.existsSync.mockReturnValue(true)
+
+      const exists = mockFs.existsSync()
+      expect(exists).toBe(true)
+    })
+
+    test('should create directory recursively', () => {
+      mockFs.mkdirSync('/repo/root/.ger', { recursive: true })
+
+      expect(mockFs.mkdirSync).toHaveBeenCalledWith('/repo/root/.ger', { recursive: true })
+    })
+
+    test('should validate change numbers', () => {
+      const validChangeNumber = '12345'
+      const invalidChangeNumber = '../../../etc/passwd'
+
+      expect(/^\d+$/.test(validChangeNumber)).toBe(true)
+      expect(/^\d+$/.test(invalidChangeNumber)).toBe(false)
+    })
+  })
+
+  describe('git operations', () => {
+    test('should execute git fetch', () => {
+      mockSpawnSync.mockReturnValue({ status: 0, stderr: '' })
+
+      const result = mockSpawnSync('git', ['fetch', 'origin', 'refs/changes/45/12345/1'], {
+        encoding: 'utf8',
+        cwd: '/repo/root',
+      })
+
+      expect(result.status).toBe(0)
+      expect(mockSpawnSync).toHaveBeenCalledWith(
+        'git',
+        ['fetch', 'origin', 'refs/changes/45/12345/1'],
+        { encoding: 'utf8', cwd: '/repo/root' },
+      )
+    })
+
+    test('should handle git fetch failure', () => {
+      mockSpawnSync.mockReturnValue({ status: 1, stderr: 'fetch failed' })
+
+      const result = mockSpawnSync('git', ['fetch', 'origin', 'refs/changes/45/12345/1'])
+
+      expect(result.status).toBe(1)
+      expect(result.stderr).toBe('fetch failed')
+    })
+
+    test('should create git worktree', () => {
+      mockSpawnSync.mockReturnValue({ status: 0, stderr: '' })
+
+      const result = mockSpawnSync('git', ['worktree', 'add', '/workspace/path', 'FETCH_HEAD'])
+
+      expect(result.status).toBe(0)
+    })
+
+    test('should handle worktree creation failure', () => {
+      mockSpawnSync.mockReturnValue({ status: 1, stderr: 'worktree add failed' })
+
+      const result = mockSpawnSync('git', ['worktree', 'add', '/workspace/path', 'FETCH_HEAD'])
+
+      expect(result.status).toBe(1)
+      expect(result.stderr).toBe('worktree add failed')
+    })
+  })
+
+  describe('output formats', () => {
+    test('should output pretty format messages', () => {
+      console.log('Fetching change 12345: Test change subject')
+      console.log('Creating worktree at: /repo/root/.ger/12345')
+      console.log('✓ Workspace created successfully!')
+      console.log('  Run: cd /repo/root/.ger/12345')
+
+      expect(mockConsole.log).toHaveBeenCalledWith('Fetching change 12345: Test change subject')
+      expect(mockConsole.log).toHaveBeenCalledWith('Creating worktree at: /repo/root/.ger/12345')
+      expect(mockConsole.log).toHaveBeenCalledWith('✓ Workspace created successfully!')
+      expect(mockConsole.log).toHaveBeenCalledWith('  Run: cd /repo/root/.ger/12345')
+    })
+
+    test('should output XML format', () => {
+      console.log('<?xml version="1.0" encoding="UTF-8"?>')
+      console.log('<workspace>')
+      console.log('  <path>/repo/root/.ger/12345</path>')
+      console.log('  <change_number>12345</change_number>')
+      console.log('  <subject><![CDATA[Test change subject]]></subject>')
+      console.log('  <created>true</created>')
+      console.log('</workspace>')
+
+      expect(mockConsole.log).toHaveBeenCalledWith('<?xml version="1.0" encoding="UTF-8"?>')
+      expect(mockConsole.log).toHaveBeenCalledWith('<workspace>')
+      expect(mockConsole.log).toHaveBeenCalledWith('  <path>/repo/root/.ger/12345</path>')
+      expect(mockConsole.log).toHaveBeenCalledWith('  <change_number>12345</change_number>')
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        '  <subject><![CDATA[Test change subject]]></subject>',
+      )
+      expect(mockConsole.log).toHaveBeenCalledWith('  <created>true</created>')
+      expect(mockConsole.log).toHaveBeenCalledWith('</workspace>')
+    })
+
+    test('should output XML format for existing workspace', () => {
+      console.log('<?xml version="1.0" encoding="UTF-8"?>')
+      console.log('<workspace>')
+      console.log('  <path>/repo/root/.ger/12345</path>')
+      console.log('  <exists>true</exists>')
+      console.log('</workspace>')
+
+      expect(mockConsole.log).toHaveBeenCalledWith('<?xml version="1.0" encoding="UTF-8"?>')
+      expect(mockConsole.log).toHaveBeenCalledWith('<workspace>')
+      expect(mockConsole.log).toHaveBeenCalledWith('  <path>/repo/root/.ger/12345</path>')
+      expect(mockConsole.log).toHaveBeenCalledWith('  <exists>true</exists>')
+      expect(mockConsole.log).toHaveBeenCalledWith('</workspace>')
+    })
+  })
+
+  describe('path safety', () => {
+    test('should prevent path traversal in workspace names', () => {
+      const maliciousPath = '../../../etc/passwd'
+      const safePath = '12345'
+
+      expect(/^\d+$/.test(maliciousPath)).toBe(false)
+      expect(/^\d+$/.test(safePath)).toBe(true)
+    })
+
+    test('should use safe path joining', () => {
+      const repoRoot = '/repo/root'
+      const changeNumber = '12345'
+      const workspacePath = `${repoRoot}/.ger/${changeNumber}`
+
+      expect(workspacePath).toBe('/repo/root/.ger/12345')
+      expect(workspacePath).not.toContain('..')
+    })
+  })
+
+  describe('error handling', () => {
+    test('should handle command execution errors', () => {
+      mockExecSync.mockImplementation(() => {
+        throw new Error('Command failed')
+      })
+
+      expect(() => {
+        mockExecSync('git status')
+      }).toThrow('Command failed')
+    })
+
+    test('should handle spawn errors', () => {
+      mockSpawnSync.mockReturnValue({
+        status: 1,
+        stderr: 'Command not found',
+      })
+
+      const result = mockSpawnSync('nonexistent-command')
+      expect(result.status).toBe(1)
+      expect(result.stderr).toBe('Command not found')
+    })
+  })
+})

package/tsconfig.json

@@ -1,10 +1,41 @@
 {
   "compilerOptions": {
-    "baseUrl": ".",
-    "module": "commonjs",
+    "lib": ["ESNext"],
+    "module": "esnext",
+    "target": "ESNext",
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "allowImportingTsExtensions": true,
     "noEmit": true,
+    "composite": false,
     "strict": true,
+    "downlevelIteration": true,
+    "skipLibCheck": true,
+    "jsx": "react",
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowJs": false,
+    "types": [
+      "bun-types"
+    ],
+    "declaration": true,
+    "isolatedDeclarations": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "outDir": "./dist",
+    "rootDir": "./",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
   },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules"]
-}
+  "include": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.json", "tests/**/*.ts", "scripts/**/*.ts"],
+  "exclude": ["node_modules", "dist", "tmp", "**/*.js", "**/*.jsx"]
+}