style: fix prettier formatting

vildanbina · vildanbina · commit edfde67a6e5c · 2026-04-09T18:56:26.000+02:00
diff --git a/src/commands/project/resolve-org.ts b/src/commands/project/resolve-org.ts
@@ -14,10 +14,7 @@ export function extractUniqueOrgs(projects: Array<{ organization: OrganizationIn
     return orgs;
 }
 
-export async function resolveOrg(
-    projects: ApiProject[],
-    orgFlag: string | undefined,
-): Promise<{ slug: string; orgs: OrganizationInfo[] }> {
+export async function resolveOrg(projects: ApiProject[], orgFlag: string | undefined): Promise<{ slug: string; orgs: OrganizationInfo[] }> {
     if (orgFlag) {
         return { slug: orgFlag, orgs: [] };
     }
diff --git a/src/prompts/project-create.ts b/src/prompts/project-create.ts
@@ -10,10 +10,7 @@ export function needsInteractiveMode(options: CreateProjectOptions): boolean {
     return !options.url && !options.github;
 }
 
-export async function runInteractiveFlow(
-    client: YavyApiClient,
-    options: CreateProjectOptions,
-): Promise<CreateProjectOptions> {
+export async function runInteractiveFlow(client: YavyApiClient, options: CreateProjectOptions): Promise<CreateProjectOptions> {
     const source = await collectSourceFromPrompts();
     const orgSlug = await resolveOrgInteractively(client, options.org);
 
@@ -36,10 +33,7 @@ export async function collectSourceFromPrompts(): Promise<Pick<CreateProjectOpti
     return { github };
 }
 
-export async function resolveOrgInteractively(
-    client: YavyApiClient,
-    orgFlag: string | undefined,
-): Promise<string> {
+export async function resolveOrgInteractively(client: YavyApiClient, orgFlag: string | undefined): Promise<string> {
     if (orgFlag) {
         return orgFlag;
     }
diff --git a/src/utils/errors.ts b/src/utils/errors.ts
@@ -46,12 +46,7 @@ function formatValidationErrors(body: unknown): string {
 }
 
 function isValidationError(body: unknown): body is ApiValidationError {
-    return (
-        typeof body === 'object' &&
-        body !== null &&
-        'errors' in body &&
-        typeof (body as ApiValidationError).errors === 'object'
-    );
+    return typeof body === 'object' && body !== null && 'errors' in body && typeof (body as ApiValidationError).errors === 'object';
 }
 
 function extractMessage(body: unknown): string {
diff --git a/tests/commands/project/build-request.test.ts b/tests/commands/project/build-request.test.ts
@@ -96,8 +96,6 @@ describe('buildCreateProjectPayload', () => {
     });
 
     it('throws when neither --url nor --github is provided', () => {
-        expect(() => buildCreateProjectPayload({})).toThrow(
-            'Either --url or --github is required.',
-        );
+        expect(() => buildCreateProjectPayload({})).toThrow('Either --url or --github is required.');
     });
 });
diff --git a/tests/commands/project/create.test.ts b/tests/commands/project/create.test.ts
@@ -22,12 +22,15 @@ import { getAccessToken } from '@/auth/store';
 import { needsInteractiveMode, runInteractiveFlow } from '@/prompts/project-create';
 
 function mockFetchResponse(status: number, body: unknown): void {
-    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-        ok: status >= 200 && status < 300,
-        status,
-        json: () => Promise.resolve(body),
-        headers: new Headers(),
-    }));
+    vi.stubGlobal(
+        'fetch',
+        vi.fn().mockResolvedValue({
+            ok: status >= 200 && status < 300,
+            status,
+            json: () => Promise.resolve(body),
+            headers: new Headers(),
+        }),
+    );
 }
 
 describe('executeCreateProject', () => {
@@ -45,57 +48,60 @@ describe('executeCreateProject', () => {
     it('throws when no token is available', async () => {
         vi.mocked(getAccessToken).mockResolvedValue(null);
 
-        await expect(executeCreateProject({ url: 'https://docs.example.com' }))
-            .rejects.toThrow('Not authenticated');
+        await expect(executeCreateProject({ url: 'https://docs.example.com' })).rejects.toThrow('Not authenticated');
     });
 
     it('throws when both --url and --github are provided', async () => {
         vi.mocked(getAccessToken).mockResolvedValue('test-token');
         mockFetchResponse(200, { data: [] });
 
-        await expect(executeCreateProject({
-            url: 'https://docs.example.com',
-            github: 'owner/repo',
-        })).rejects.toThrow('not both');
+        await expect(
+            executeCreateProject({
+                url: 'https://docs.example.com',
+                github: 'owner/repo',
+            }),
+        ).rejects.toThrow('not both');
     });
 
     it('throws when no source is provided and interactive mode is skipped', async () => {
         vi.mocked(getAccessToken).mockResolvedValue('test-token');
         vi.mocked(needsInteractiveMode).mockReturnValue(false);
         mockFetchResponse(200, { data: [] });
 
-        await expect(executeCreateProject({}))
-            .rejects.toThrow('--url or --github is required');
+        await expect(executeCreateProject({})).rejects.toThrow('--url or --github is required');
     });
 
     it('creates a project successfully with --url and --org', async () => {
         vi.mocked(getAccessToken).mockResolvedValue('test-token');
 
-        const fetchMock = vi.fn()
+        const fetchMock = vi
+            .fn()
             .mockResolvedValueOnce({
                 ok: true,
                 status: 200,
-                json: () => Promise.resolve({
-                    data: [{ organization: { name: 'My Org', slug: 'my-org' } }],
-                }),
+                json: () =>
+                    Promise.resolve({
+                        data: [{ organization: { name: 'My Org', slug: 'my-org' } }],
+                    }),
                 headers: new Headers(),
             })
             .mockResolvedValueOnce({
                 ok: true,
                 status: 201,
-                json: () => Promise.resolve({
-                    data: {
-                        id: 1,
-                        name: 'Example Docs',
-                        slug: 'example-docs',
-                        description: null,
-                        organization: { name: 'My Org', slug: 'my-org' },
-                        pages_count: 0,
-                        last_indexed_at: null,
-                        has_indexed_content: false,
-                        mcp_url: 'https://yavy.dev/mcp/my-org/example-docs',
-                    },
-                }),
+                json: () =>
+                    Promise.resolve({
+                        data: {
+                            id: 1,
+                            name: 'Example Docs',
+                            slug: 'example-docs',
+                            description: null,
+                            organization: { name: 'My Org', slug: 'my-org' },
+                            pages_count: 0,
+                            last_indexed_at: null,
+                            has_indexed_content: false,
+                            mcp_url: 'https://yavy.dev/mcp/my-org/example-docs',
+                        },
+                    }),
                 headers: new Headers(),
             });
         vi.stubGlobal('fetch', fetchMock);
@@ -105,39 +111,40 @@ describe('executeCreateProject', () => {
             org: 'my-org',
         });
 
-        expect(consoleSpy).toHaveBeenCalledWith(
-            expect.stringContaining('Project created successfully!'),
-        );
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Project created successfully!'));
     });
 
     it('auto-selects org when user has exactly one', async () => {
         vi.mocked(getAccessToken).mockResolvedValue('test-token');
 
-        const fetchMock = vi.fn()
+        const fetchMock = vi
+            .fn()
             .mockResolvedValueOnce({
                 ok: true,
                 status: 200,
-                json: () => Promise.resolve({
-                    data: [{ organization: { name: 'Solo Org', slug: 'solo-org' } }],
-                }),
+                json: () =>
+                    Promise.resolve({
+                        data: [{ organization: { name: 'Solo Org', slug: 'solo-org' } }],
+                    }),
                 headers: new Headers(),
             })
             .mockResolvedValueOnce({
                 ok: true,
                 status: 201,
-                json: () => Promise.resolve({
-                    data: {
-                        id: 2,
-                        name: 'Docs',
-                        slug: 'docs',
-                        description: null,
-                        organization: { name: 'Solo Org', slug: 'solo-org' },
-                        pages_count: 0,
-                        last_indexed_at: null,
-                        has_indexed_content: false,
-                        mcp_url: 'https://yavy.dev/mcp/solo-org/docs',
-                    },
-                }),
+                json: () =>
+                    Promise.resolve({
+                        data: {
+                            id: 2,
+                            name: 'Docs',
+                            slug: 'docs',
+                            description: null,
+                            organization: { name: 'Solo Org', slug: 'solo-org' },
+                            pages_count: 0,
+                            last_indexed_at: null,
+                            has_indexed_content: false,
+                            mcp_url: 'https://yavy.dev/mcp/solo-org/docs',
+                        },
+                    }),
                 headers: new Headers(),
             });
         vi.stubGlobal('fetch', fetchMock);
@@ -159,40 +166,41 @@ describe('executeCreateProject', () => {
             name: 'Interactive Project',
         });
 
-        const fetchMock = vi.fn()
+        const fetchMock = vi
+            .fn()
             .mockResolvedValueOnce({
                 ok: true,
                 status: 200,
-                json: () => Promise.resolve({
-                    data: [{ organization: { name: 'My Org', slug: 'my-org' } }],
-                }),
+                json: () =>
+                    Promise.resolve({
+                        data: [{ organization: { name: 'My Org', slug: 'my-org' } }],
+                    }),
                 headers: new Headers(),
             })
             .mockResolvedValueOnce({
                 ok: true,
                 status: 201,
-                json: () => Promise.resolve({
-                    data: {
-                        id: 3,
-                        name: 'Interactive Project',
-                        slug: 'interactive-project',
-                        description: null,
-                        organization: { name: 'My Org', slug: 'my-org' },
-                        pages_count: 0,
-                        last_indexed_at: null,
-                        has_indexed_content: false,
-                        mcp_url: 'https://yavy.dev/mcp/my-org/interactive-project',
-                    },
-                }),
+                json: () =>
+                    Promise.resolve({
+                        data: {
+                            id: 3,
+                            name: 'Interactive Project',
+                            slug: 'interactive-project',
+                            description: null,
+                            organization: { name: 'My Org', slug: 'my-org' },
+                            pages_count: 0,
+                            last_indexed_at: null,
+                            has_indexed_content: false,
+                            mcp_url: 'https://yavy.dev/mcp/my-org/interactive-project',
+                        },
+                    }),
                 headers: new Headers(),
             });
         vi.stubGlobal('fetch', fetchMock);
 
         await executeCreateProject({});
 
         expect(runInteractiveFlow).toHaveBeenCalled();
-        expect(consoleSpy).toHaveBeenCalledWith(
-            expect.stringContaining('Project created successfully!'),
-        );
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Project created successfully!'));
     });
 });
diff --git a/tests/commands/project/resolve-org.test.ts b/tests/commands/project/resolve-org.test.ts
@@ -22,10 +22,7 @@ describe('extractUniqueOrgs', () => {
     });
 
     it('returns single org when all projects belong to one', () => {
-        const projects = [
-            { organization: { name: 'Solo', slug: 'solo' } },
-            { organization: { name: 'Solo', slug: 'solo' } },
-        ];
+        const projects = [{ organization: { name: 'Solo', slug: 'solo' } }, { organization: { name: 'Solo', slug: 'solo' } }];
 
         const orgs = extractUniqueOrgs(projects);
 
@@ -42,20 +39,15 @@ describe('resolveOrg', () => {
     });
 
     it('auto-selects when user has exactly one org', async () => {
-        const projects = [
-            { organization: { name: 'Solo Org', slug: 'solo-org' } },
-        ] as never[];
+        const projects = [{ organization: { name: 'Solo Org', slug: 'solo-org' } }] as never[];
 
         const result = await resolveOrg(projects, undefined);
 
         expect(result.slug).toBe('solo-org');
     });
 
     it('returns empty slug with orgs list when multiple orgs exist', async () => {
-        const projects = [
-            { organization: { name: 'Org A', slug: 'org-a' } },
-            { organization: { name: 'Org B', slug: 'org-b' } },
-        ] as never[];
+        const projects = [{ organization: { name: 'Org A', slug: 'org-a' } }, { organization: { name: 'Org B', slug: 'org-b' } }] as never[];
 
         const result = await resolveOrg(projects, undefined);
 
diff --git a/tests/prompts/project-create.test.ts b/tests/prompts/project-create.test.ts
@@ -27,12 +27,7 @@ vi.mock('@/commands/project/resolve-org', () => ({
 
 import * as p from '@clack/prompts';
 import { resolveOrg } from '@/commands/project/resolve-org';
-import {
-    collectSourceFromPrompts,
-    needsInteractiveMode,
-    resolveOrgInteractively,
-    runInteractiveFlow,
-} from '@/prompts/project-create';
+import { collectSourceFromPrompts, needsInteractiveMode, resolveOrgInteractively, runInteractiveFlow } from '@/prompts/project-create';
 
 describe('needsInteractiveMode', () => {
     it('returns true when no source flag is provided', () => {
@@ -64,9 +59,7 @@ describe('collectSourceFromPrompts', () => {
         const result = await collectSourceFromPrompts();
 
         expect(result).toEqual({ url: 'https://docs.example.com' });
-        expect(p.select).toHaveBeenCalledWith(
-            expect.objectContaining({ message: 'What type of documentation source?' }),
-        );
+        expect(p.select).toHaveBeenCalledWith(expect.objectContaining({ message: 'What type of documentation source?' }));
     });
 
     it('prompts for owner/repo when user selects GitHub', async () => {
@@ -101,9 +94,7 @@ describe('resolveOrgInteractively', () => {
     });
 
     it('auto-selects when user has exactly one org', async () => {
-        mockClient.listProjects.mockResolvedValue([
-            { organization: { name: 'Solo Org', slug: 'solo-org' } },
-        ]);
+        mockClient.listProjects.mockResolvedValue([{ organization: { name: 'Solo Org', slug: 'solo-org' } }]);
         vi.mocked(resolveOrg).mockResolvedValue({
             slug: 'solo-org',
             orgs: [{ name: 'Solo Org', slug: 'solo-org' }],
@@ -119,10 +110,7 @@ describe('resolveOrgInteractively', () => {
             { name: 'Org A', slug: 'org-a' },
             { name: 'Org B', slug: 'org-b' },
         ];
-        mockClient.listProjects.mockResolvedValue([
-            { organization: orgs[0] },
-            { organization: orgs[1] },
-        ]);
+        mockClient.listProjects.mockResolvedValue([{ organization: orgs[0] }, { organization: orgs[1] }]);
         vi.mocked(resolveOrg).mockResolvedValue({ slug: '', orgs });
         vi.mocked(p.select).mockResolvedValueOnce('org-b');
 
@@ -144,9 +132,7 @@ describe('runInteractiveFlow', () => {
 
     it('merges prompt results with existing options', async () => {
         const mockClient = {
-            listProjects: vi.fn().mockResolvedValue([
-                { organization: { name: 'My Org', slug: 'my-org' } },
-            ]),
+            listProjects: vi.fn().mockResolvedValue([{ organization: { name: 'My Org', slug: 'my-org' } }]),
             createProject: vi.fn(),
         };
         vi.mocked(resolveOrg).mockResolvedValue({

Original file line number	Diff line number	Diff line change
`@@ -14,10 +14,7 @@ export function extractUniqueOrgs(projects: Array<{ organization: OrganizationIn`
`14`	`14`	`return orgs;`
`15`	`15`	`}`
`16`	`16`
`17`		`-export async function resolveOrg(`
`18`		`- projects: ApiProject[],`
`19`		`- orgFlag: string \| undefined,`
`20`		`-): Promise<{ slug: string; orgs: OrganizationInfo[] }> {`
	`17`	`+export async function resolveOrg(projects: ApiProject[], orgFlag: string \| undefined): Promise<{ slug: string; orgs: OrganizationInfo[] }> {`
`21`	`18`	`if (orgFlag) {`
`22`	`19`	`return { slug: orgFlag, orgs: [] };`
`23`	`20`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,12 +46,7 @@ function formatValidationErrors(body: unknown): string {`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`function isValidationError(body: unknown): body is ApiValidationError {`
`49`		`- return (`
`50`		`- typeof body === 'object' &&`
`51`		`- body !== null &&`
`52`		`- 'errors' in body &&`
`53`		`- typeof (body as ApiValidationError).errors === 'object'`
`54`		`- );`
	`49`	`+ return typeof body === 'object' && body !== null && 'errors' in body && typeof (body as ApiValidationError).errors === 'object';`
`55`	`50`	`}`
`56`	`51`
`57`	`52`	`function extractMessage(body: unknown): string {`