@tanstack/cli 0.0.8 → 0.48.3

package/tests/command-line.test.ts

@@ -0,0 +1,304 @@
+import { basename, resolve } from 'node:path'
+import { beforeEach, describe, expect, it } from 'vitest'
+
+import { normalizeOptions } from '../src/command-line.js'
+import {
+  sanitizePackageName,
+  getCurrentDirectoryName,
+} from '../src/utils.js'
+import {
+  __testRegisterFramework,
+  __testClearFrameworks,
+} from '@tanstack/create'
+
+beforeEach(() => {
+  __testClearFrameworks()
+})
+
+describe('sanitizePackageName', () => {
+  it('should convert to lowercase', () => {
+    expect(sanitizePackageName('MyProject')).toBe('myproject')
+  })
+
+  it('should replace spaces with hyphens', () => {
+    expect(sanitizePackageName('my project')).toBe('my-project')
+  })
+
+  it('should replace underscores with hyphens', () => {
+    expect(sanitizePackageName('my_project')).toBe('my-project')
+  })
+
+  it('should remove invalid characters', () => {
+    expect(sanitizePackageName('my@project!')).toBe('myproject')
+  })
+
+  it('should ensure it starts with a letter', () => {
+    expect(sanitizePackageName('123project')).toBe('project')
+    expect(sanitizePackageName('_myproject')).toBe('myproject')
+  })
+
+  it('should collapse multiple hyphens', () => {
+    expect(sanitizePackageName('my--project')).toBe('my-project')
+  })
+
+  it('should remove trailing hyphen', () => {
+    expect(sanitizePackageName('myproject-')).toBe('myproject')
+  })
+})
+
+describe('getCurrentDirectoryName', () => {
+  it('should return the basename of the current working directory', () => {
+    expect(getCurrentDirectoryName()).toBe(basename(process.cwd()))
+  })
+})
+
+describe('normalizeOptions', () => {
+  it('should return undefined if project name is not provided', async () => {
+    const options = await normalizeOptions({})
+    expect(options).toBeUndefined()
+  })
+
+  it('should handle "." as project name by using sanitized current directory name', async () => {
+    const options = await normalizeOptions({
+      projectName: '.',
+    })
+    const expectedName = sanitizePackageName(getCurrentDirectoryName())
+    expect(options?.projectName).toBe(expectedName)
+    expect(options?.targetDir).toBe(resolve(process.cwd()))
+  })
+
+  it('should return enable typescript based on the framework', async () => {
+    const jsOptions = await normalizeOptions({
+      projectName: 'test',
+      template: 'javascript',
+    })
+    expect(jsOptions?.typescript).toBe(false)
+    expect(jsOptions?.mode).toBe('code-router')
+
+    const tsOptions = await normalizeOptions({
+      projectName: 'test',
+      template: 'typescript',
+    })
+    expect(tsOptions?.typescript).toBe(true)
+    expect(tsOptions?.mode).toBe('code-router')
+
+    const frOptions = await normalizeOptions({
+      projectName: 'test',
+      template: 'file-router',
+    })
+    expect(frOptions?.typescript).toBe(true)
+    expect(frOptions?.mode).toBe('file-router')
+  })
+
+  it('should return enable tailwind if the framework is solid', async () => {
+    const solidOptions = await normalizeOptions({
+      projectName: 'test',
+      framework: 'solid',
+    })
+    expect(solidOptions?.tailwind).toBe(true)
+
+    const twOptions = await normalizeOptions({
+      projectName: 'test',
+      tailwind: true,
+    })
+    expect(twOptions?.tailwind).toBe(true)
+
+    const noOptions = await normalizeOptions({
+      projectName: 'test',
+    })
+    expect(noOptions?.tailwind).toBe(false)
+  })
+
+  it('should handle a starter url', async () => {
+    __testRegisterFramework({
+      id: 'solid',
+      name: 'Solid',
+      getAddOns: () => [
+        {
+          id: 'nitro',
+          name: 'nitro',
+          modes: ['file-router'],
+          default: true,
+        },
+      ],
+      supportedModes: {
+        'code-router': {
+          displayName: 'Code Router',
+          description: 'TanStack Router using code to define the routes',
+          forceTypescript: false,
+        },
+        'file-router': {
+          displayName: 'File Router',
+          description: 'TanStack Router using files to define the routes',
+          forceTypescript: true,
+        },
+      },
+    })
+    fetch.mockResponseOnce(
+      JSON.stringify({
+        id: 'https://github.com/cta-dev/cta-starter-solid',
+        tailwind: true,
+        typescript: false,
+        framework: 'solid',
+        mode: 'file-router',
+        type: 'starter',
+        description: 'A starter for Solid',
+        name: 'My Solid Starter',
+        dependsOn: [],
+        files: {},
+        deletedFiles: [],
+      }),
+    )
+
+    const options = await normalizeOptions({
+      projectName: 'test',
+      starter: 'https://github.com/cta-dev/cta-starter-solid',
+      deployment: 'nitro',
+    })
+    expect(options?.mode).toBe('file-router')
+    expect(options?.tailwind).toBe(true)
+    expect(options?.typescript).toBe(true)
+    expect(options?.framework?.id).toBe('solid')
+  })
+
+  it('should default to react-cra if no framework is provided', async () => {
+    __testRegisterFramework({
+      id: 'react-cra',
+      name: 'react',
+    })
+    const options = await normalizeOptions({
+      projectName: 'test',
+    })
+    expect(options?.framework?.id).toBe('react-cra')
+  })
+
+  it('should handle forced addons', async () => {
+    __testRegisterFramework({
+      id: 'react-cra',
+      name: 'react',
+      getAddOns: () => [
+        {
+          id: 'foo',
+          name: 'foobar',
+          modes: ['file-router'],
+        },
+        {
+          id: 'nitro',
+          name: 'nitro',
+          modes: ['file-router'],
+          default: true,
+        },
+      ],
+    })
+    const options = await normalizeOptions(
+      {
+        projectName: 'test',
+        framework: 'react-cra',
+      },
+      'file-router',
+      ['foo'],
+    )
+    expect(options?.chosenAddOns.map((a) => a.id).includes('foo')).toBe(true)
+  })
+
+  it('should handle additional addons from the CLI', async () => {
+    __testRegisterFramework({
+      id: 'react-cra',
+      name: 'react',
+      getAddOns: () => [
+        {
+          id: 'foo',
+          name: 'foobar',
+          modes: ['file-router'],
+        },
+        {
+          id: 'baz',
+          name: 'baz',
+          modes: ['file-router'],
+        },
+        {
+          id: 'nitro',
+          name: 'nitro',
+          modes: ['file-router'],
+          default: true,
+        },
+      ],
+    })
+    const options = await normalizeOptions(
+      {
+        projectName: 'test',
+        addOns: ['baz'],
+        framework: 'react-cra',
+        template: 'file-router',
+      },
+      'file-router',
+      ['foo'],
+    )
+    expect(options?.chosenAddOns.map((a) => a.id).includes('foo')).toBe(true)
+    expect(options?.chosenAddOns.map((a) => a.id).includes('baz')).toBe(true)
+    // Tailwind is not automatically set to true unless an add-on explicitly requires it
+    // Since mock add-ons don't have tailwind: true, tailwind should be false
+    expect(options?.tailwind).toBe(false)
+    expect(options?.typescript).toBe(true)
+  })
+
+  it('should handle toolchain as an addon', async () => {
+    __testRegisterFramework({
+      id: 'react-cra',
+      name: 'react',
+      getAddOns: () => [
+        {
+          id: 'biome',
+          name: 'Biome',
+          modes: ['file-router', 'code-router'],
+        },
+        {
+          id: 'nitro',
+          name: 'nitro',
+          modes: ['file-router', 'code-router'],
+          default: true,
+        },
+      ],
+    })
+    const options = await normalizeOptions({
+      projectName: 'test',
+      toolchain: 'biome',
+    })
+    expect(options?.chosenAddOns.map((a) => a.id).includes('biome')).toBe(true)
+    // Tailwind is not automatically set to true unless an add-on explicitly requires it
+    // Since mock add-ons don't have tailwind: true, tailwind should be false
+    expect(options?.tailwind).toBe(false)
+    expect(options?.typescript).toBe(true)
+  })
+
+  it('should handle the funky Windows edge case with CLI parsing', async () => {
+    __testRegisterFramework({
+      id: 'react-cra',
+      name: 'react',
+      getAddOns: () => [
+        {
+          id: 'foo',
+          name: 'foobar',
+          modes: ['file-router', 'code-router'],
+        },
+        {
+          id: 'baz',
+          name: 'baz',
+          modes: ['file-router', 'code-router'],
+        },
+        {
+          id: 'nitro',
+          name: 'nitro',
+          modes: ['file-router', 'code-router'],
+          default: true,
+        },
+      ],
+    })
+    const options = await normalizeOptions({
+      projectName: 'test',
+      addOns: ['baz foo'],
+    })
+    expect(options?.chosenAddOns.map((a) => a.id).includes('foo')).toBe(true)
+    expect(options?.chosenAddOns.map((a) => a.id).includes('baz')).toBe(true)
+  })
+})

package/tests/index.test.ts

@@ -0,0 +1,9 @@
+import { describe, it, expect } from 'vitest'
+
+import { cli } from '../src/index.js'
+
+describe('cli', () => {
+  it('should call the cli with the correct arguments', async () => {
+    expect(cli).toBeDefined()
+  })
+})

package/tests/mcp.test.ts

@@ -0,0 +1,225 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { registerDocTools } from '../src/mcp/tools.js'
+import * as api from '../src/mcp/api.js'
+
+vi.mock('../src/mcp/api.js')
+
+const mockLibrariesResponse = {
+  libraries: [
+    {
+      id: 'query',
+      name: 'TanStack Query',
+      tagline: 'Powerful asynchronous state management',
+      description: 'Data fetching library',
+      frameworks: ['react', 'vue', 'solid'],
+      latestVersion: 'v5',
+      latestBranch: 'main',
+      availableVersions: ['v5', 'v4'],
+      docsUrl: 'https://tanstack.com/query',
+      githubUrl: 'https://github.com/TanStack/query',
+      repo: 'TanStack/query',
+      docsRoot: 'docs',
+    },
+    {
+      id: 'router',
+      name: 'TanStack Router',
+      tagline: 'Type-safe routing',
+      description: 'Router library',
+      frameworks: ['react'],
+      latestVersion: 'v1',
+      latestBranch: 'main',
+      availableVersions: ['v1'],
+      docsUrl: 'https://tanstack.com/router',
+      githubUrl: 'https://github.com/TanStack/router',
+      repo: 'TanStack/router',
+      docsRoot: 'docs',
+    },
+  ],
+  groups: {
+    state: ['query'],
+    headlessUI: [],
+    performance: [],
+    tooling: ['router'],
+  },
+  groupNames: {
+    state: 'State Management',
+    headlessUI: 'Headless UI',
+    performance: 'Performance',
+    tooling: 'Tooling',
+  },
+}
+
+const mockPartnersResponse = {
+  partners: [
+    {
+      id: 'neon',
+      name: 'Neon',
+      description: 'Serverless Postgres',
+      category: 'database',
+      categoryLabel: 'Database',
+      libraries: ['start', 'router'],
+      url: 'https://neon.tech',
+    },
+  ],
+  categories: ['database', 'auth'],
+  categoryLabels: {
+    database: 'Database',
+    auth: 'Authentication',
+  },
+}
+
+describe('MCP Tools', () => {
+  let server: McpServer
+  let registeredTools: Map<string, { handler: Function; schema: unknown }>
+
+  beforeEach(() => {
+    vi.resetAllMocks()
+
+    // Create a mock server that captures tool registrations
+    registeredTools = new Map()
+    server = {
+      tool: vi.fn((name, description, schema, handler) => {
+        registeredTools.set(name, { handler, schema })
+      }),
+    } as unknown as McpServer
+
+    vi.mocked(api.fetchLibraries).mockResolvedValue(mockLibrariesResponse)
+    vi.mocked(api.fetchPartners).mockResolvedValue(mockPartnersResponse)
+    vi.mocked(api.fetchDocContent).mockResolvedValue('# Test Doc\n\nContent here')
+
+    registerDocTools(server)
+  })
+
+  describe('tanstack_list_libraries', () => {
+    it('should register the tool', () => {
+      expect(registeredTools.has('tanstack_list_libraries')).toBe(true)
+    })
+
+    it('should list all libraries when no group specified', async () => {
+      const tool = registeredTools.get('tanstack_list_libraries')!
+      const result = await tool.handler({})
+
+      expect(result.content[0].type).toBe('text')
+      const data = JSON.parse(result.content[0].text)
+      expect(data.count).toBe(2)
+      expect(data.libraries).toHaveLength(2)
+    })
+
+    it('should filter libraries by group', async () => {
+      const tool = registeredTools.get('tanstack_list_libraries')!
+      const result = await tool.handler({ group: 'state' })
+
+      const data = JSON.parse(result.content[0].text)
+      expect(data.count).toBe(1)
+      expect(data.libraries[0].id).toBe('query')
+      expect(data.group).toBe('State Management')
+    })
+
+    it('should handle API errors', async () => {
+      vi.mocked(api.fetchLibraries).mockRejectedValue(new Error('Network error'))
+
+      const tool = registeredTools.get('tanstack_list_libraries')!
+      const result = await tool.handler({})
+
+      expect(result.isError).toBe(true)
+      expect(result.content[0].text).toContain('Error')
+    })
+  })
+
+  describe('tanstack_doc', () => {
+    it('should register the tool', () => {
+      expect(registeredTools.has('tanstack_doc')).toBe(true)
+    })
+
+    it('should fetch doc content', async () => {
+      const tool = registeredTools.get('tanstack_doc')!
+      const result = await tool.handler({
+        library: 'query',
+        path: 'framework/react/overview',
+      })
+
+      expect(api.fetchDocContent).toHaveBeenCalledWith(
+        'TanStack/query',
+        'main',
+        'docs/framework/react/overview.md',
+      )
+
+      const data = JSON.parse(result.content[0].text)
+      expect(data.content).toContain('# Test Doc')
+    })
+
+    it('should error for unknown library', async () => {
+      const tool = registeredTools.get('tanstack_doc')!
+      const result = await tool.handler({
+        library: 'unknown',
+        path: 'overview',
+      })
+
+      expect(result.isError).toBe(true)
+      expect(result.content[0].text).toContain('not found')
+    })
+
+    it('should error for unknown version', async () => {
+      const tool = registeredTools.get('tanstack_doc')!
+      const result = await tool.handler({
+        library: 'query',
+        path: 'overview',
+        version: 'v999',
+      })
+
+      expect(result.isError).toBe(true)
+      expect(result.content[0].text).toContain('Version')
+    })
+
+    it('should handle 404 doc', async () => {
+      vi.mocked(api.fetchDocContent).mockResolvedValue(null)
+
+      const tool = registeredTools.get('tanstack_doc')!
+      const result = await tool.handler({
+        library: 'query',
+        path: 'nonexistent',
+      })
+
+      expect(result.isError).toBe(true)
+      expect(result.content[0].text).toContain('not found')
+    })
+  })
+
+  describe('tanstack_ecosystem', () => {
+    it('should register the tool', () => {
+      expect(registeredTools.has('tanstack_ecosystem')).toBe(true)
+    })
+
+    it('should list ecosystem partners', async () => {
+      const tool = registeredTools.get('tanstack_ecosystem')!
+      const result = await tool.handler({})
+
+      const data = JSON.parse(result.content[0].text)
+      expect(data.partners).toHaveLength(1)
+      expect(data.partners[0].id).toBe('neon')
+    })
+
+    it('should filter by category', async () => {
+      const tool = registeredTools.get('tanstack_ecosystem')!
+      const result = await tool.handler({ category: 'database' })
+
+      const data = JSON.parse(result.content[0].text)
+      expect(data.partners).toHaveLength(1)
+    })
+
+    it('should filter by library', async () => {
+      const tool = registeredTools.get('tanstack_ecosystem')!
+      const result = await tool.handler({ library: 'start' })
+
+      const data = JSON.parse(result.content[0].text)
+      expect(data.partners).toHaveLength(1)
+    })
+  })
+
+  describe('tanstack_search_docs', () => {
+    it('should register the tool', () => {
+      expect(registeredTools.has('tanstack_search_docs')).toBe(true)
+    })
+  })
+})