@_davideast/stitch-mcp 0.0.1

package/dist/src/services/mcp-config/spec.d.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+export type McpClient = 'antigravity' | 'vscode' | 'cursor' | 'claude-code' | 'gemini-cli';
+export type TransportType = 'http' | 'stdio';
+export declare const GenerateConfigInputSchema: z.ZodObject<{
+    client: z.ZodEnum<["antigravity", "vscode", "cursor", "claude-code", "gemini-cli"]>;
+    projectId: z.ZodString;
+    accessToken: z.ZodString;
+    transport: z.ZodDefault<z.ZodEnum<["http", "stdio"]>>;
+}, "strip", z.ZodTypeAny, {
+    client: "antigravity" | "vscode" | "cursor" | "claude-code" | "gemini-cli";
+    transport: "http" | "stdio";
+    projectId: string;
+    accessToken: string;
+}, {
+    client: "antigravity" | "vscode" | "cursor" | "claude-code" | "gemini-cli";
+    projectId: string;
+    accessToken: string;
+    transport?: "http" | "stdio" | undefined;
+}>;
+export type GenerateConfigInput = z.infer<typeof GenerateConfigInputSchema>;
+export declare const McpConfigErrorCode: z.ZodEnum<["INVALID_CLIENT", "CONFIG_GENERATION_FAILED", "UNKNOWN_ERROR"]>;
+export declare const McpConfigSuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        config: z.ZodString;
+        instructions: z.ZodString;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        instructions: string;
+        config: string;
+        filePath?: string | undefined;
+    }, {
+        instructions: string;
+        config: string;
+        filePath?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        instructions: string;
+        config: string;
+        filePath?: string | undefined;
+    };
+}, {
+    success: true;
+    data: {
+        instructions: string;
+        config: string;
+        filePath?: string | undefined;
+    };
+}>;
+export declare const McpConfigFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["INVALID_CLIENT", "CONFIG_GENERATION_FAILED", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        recoverable: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        code: "CONFIG_GENERATION_FAILED" | "UNKNOWN_ERROR" | "INVALID_CLIENT";
+        message: string;
+        recoverable: boolean;
+    }, {
+        code: "CONFIG_GENERATION_FAILED" | "UNKNOWN_ERROR" | "INVALID_CLIENT";
+        message: string;
+        recoverable: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "CONFIG_GENERATION_FAILED" | "UNKNOWN_ERROR" | "INVALID_CLIENT";
+        message: string;
+        recoverable: boolean;
+    };
+}, {
+    success: false;
+    error: {
+        code: "CONFIG_GENERATION_FAILED" | "UNKNOWN_ERROR" | "INVALID_CLIENT";
+        message: string;
+        recoverable: boolean;
+    };
+}>;
+export type McpConfigResult = z.infer<typeof McpConfigSuccess> | z.infer<typeof McpConfigFailure>;
+export interface McpConfigService {
+    /**
+     * Generate MCP configuration for specified client
+     */
+    generateConfig(input: GenerateConfigInput): Promise<McpConfigResult>;
+}

package/dist/src/services/mcp-config/spec.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/services/project/handler.d.ts

@@ -0,0 +1,11 @@
+import { type ProjectService, type SelectProjectInput, type ProjectSelectionResult } from './spec.js';
+import { type GcloudService } from '../gcloud/spec.js';
+export declare class ProjectHandler implements ProjectService {
+    private gcloudService;
+    constructor(gcloudService: GcloudService);
+    selectProject(input: SelectProjectInput): Promise<ProjectSelectionResult>;
+    getProjectDetails(input: {
+        projectId: string;
+    }): Promise<ProjectSelectionResult>;
+    private searchAndSelect;
+}

package/dist/src/services/project/handler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/services/project/spec.d.ts

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+export declare const SelectProjectInputSchema: z.ZodObject<{
+    allowSearch: z.ZodDefault<z.ZodBoolean>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    allowSearch: boolean;
+}, {
+    limit?: number | undefined;
+    allowSearch?: boolean | undefined;
+}>;
+export type SelectProjectInput = z.infer<typeof SelectProjectInputSchema>;
+export declare const ProjectErrorCode: z.ZodEnum<["NO_PROJECTS_FOUND", "SELECTION_CANCELLED", "SEARCH_FAILED", "PROJECT_FETCH_FAILED", "PROJECT_NOT_FOUND", "UNKNOWN_ERROR"]>;
+export declare const ProjectSelectionSuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        projectId: z.ZodString;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        projectId: string;
+        name: string;
+    }, {
+        projectId: string;
+        name: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        projectId: string;
+        name: string;
+    };
+}, {
+    success: true;
+    data: {
+        projectId: string;
+        name: string;
+    };
+}>;
+export declare const ProjectSelectionFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["NO_PROJECTS_FOUND", "SELECTION_CANCELLED", "SEARCH_FAILED", "PROJECT_FETCH_FAILED", "PROJECT_NOT_FOUND", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+        recoverable: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        code: "UNKNOWN_ERROR" | "NO_PROJECTS_FOUND" | "SELECTION_CANCELLED" | "SEARCH_FAILED" | "PROJECT_FETCH_FAILED" | "PROJECT_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }, {
+        code: "UNKNOWN_ERROR" | "NO_PROJECTS_FOUND" | "SELECTION_CANCELLED" | "SEARCH_FAILED" | "PROJECT_FETCH_FAILED" | "PROJECT_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "NO_PROJECTS_FOUND" | "SELECTION_CANCELLED" | "SEARCH_FAILED" | "PROJECT_FETCH_FAILED" | "PROJECT_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    };
+}, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "NO_PROJECTS_FOUND" | "SELECTION_CANCELLED" | "SEARCH_FAILED" | "PROJECT_FETCH_FAILED" | "PROJECT_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    };
+}>;
+export type ProjectSelectionResult = z.infer<typeof ProjectSelectionSuccess> | z.infer<typeof ProjectSelectionFailure>;
+export interface ProjectService {
+    /**
+     * Prompt user to select a project
+     */
+    selectProject(input: SelectProjectInput): Promise<ProjectSelectionResult>;
+    /**
+     * Get details for a specific project
+     */
+    getProjectDetails(input: {
+        projectId: string;
+    }): Promise<ProjectSelectionResult>;
+}

package/dist/src/services/project/spec.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/services/proxy/handler.d.ts

@@ -0,0 +1,15 @@
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { type ProxyService, type StartProxyInput, type ProxyResult } from './spec.js';
+import { GcloudHandler } from '../gcloud/handler.js';
+export declare class ProxyHandler implements ProxyService {
+    private gcloud;
+    private transportFactory;
+    private currentToken;
+    private refreshTimer;
+    private pendingToolListIds;
+    constructor(gcloud?: GcloudHandler, transportFactory?: () => StdioServerTransport);
+    start(input: StartProxyInput): Promise<ProxyResult>;
+    private refreshToken;
+    private startRefreshTimer;
+    private stopRefreshTimer;
+}

package/dist/src/services/proxy/handler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/services/proxy/spec.d.ts

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+export declare const StartProxyInputSchema: z.ZodObject<{
+    transport: z.ZodDefault<z.ZodEnum<["stdio", "sse"]>>;
+    port: z.ZodOptional<z.ZodNumber>;
+    debug: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    transport: "stdio" | "sse";
+    port?: number | undefined;
+    debug?: boolean | undefined;
+}, {
+    transport?: "stdio" | "sse" | undefined;
+    port?: number | undefined;
+    debug?: boolean | undefined;
+}>;
+export type StartProxyInput = z.infer<typeof StartProxyInputSchema>;
+export declare const ProxyErrorCode: z.ZodEnum<["START_FAILED", "TRANSPORT_ERROR", "AUTH_REFRESH_FAILED", "UNKNOWN_ERROR"]>;
+export type ProxyErrorCodeType = z.infer<typeof ProxyErrorCode>;
+export declare const ProxySuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        status: z.ZodEnum<["running", "stopped"]>;
+    }, "strip", z.ZodTypeAny, {
+        status: "running" | "stopped";
+    }, {
+        status: "running" | "stopped";
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        status: "running" | "stopped";
+    };
+}, {
+    success: true;
+    data: {
+        status: "running" | "stopped";
+    };
+}>;
+export declare const ProxyFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["START_FAILED", "TRANSPORT_ERROR", "AUTH_REFRESH_FAILED", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+        recoverable: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        code: "UNKNOWN_ERROR" | "START_FAILED" | "TRANSPORT_ERROR" | "AUTH_REFRESH_FAILED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }, {
+        code: "UNKNOWN_ERROR" | "START_FAILED" | "TRANSPORT_ERROR" | "AUTH_REFRESH_FAILED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "START_FAILED" | "TRANSPORT_ERROR" | "AUTH_REFRESH_FAILED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    };
+}, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "START_FAILED" | "TRANSPORT_ERROR" | "AUTH_REFRESH_FAILED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    };
+}>;
+export type ProxyResult = z.infer<typeof ProxySuccess> | z.infer<typeof ProxyFailure>;
+export interface ProxyService {
+    /**
+     * Start the MCP proxy server
+     *
+     * @remarks
+     * This is a long-running operation. The promise settles only when the server stops
+     * or if initial startup fails.
+     */
+    start(input: StartProxyInput): Promise<ProxyResult>;
+}

package/dist/src/services/proxy/spec.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/services/stitch/handler.d.ts

@@ -0,0 +1,15 @@
+import { type StitchService, type ConfigureIAMInput, type EnableAPIInput, type TestConnectionInput, type IAMConfigResult, type APIEnableResult, type ConnectionTestResult } from './spec.js';
+export declare class StitchHandler implements StitchService {
+    private getGcloudEnv;
+    private getGcloudBinary;
+    configureIAM(input: ConfigureIAMInput): Promise<IAMConfigResult>;
+    enableAPI(input: EnableAPIInput): Promise<APIEnableResult>;
+    checkIAMRole(input: {
+        projectId: string;
+        userEmail: string;
+    }): Promise<boolean>;
+    checkAPIEnabled(input: {
+        projectId: string;
+    }): Promise<boolean>;
+    testConnection(input: TestConnectionInput): Promise<ConnectionTestResult>;
+}

package/dist/src/services/stitch/handler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/services/stitch/spec.d.ts

@@ -0,0 +1,262 @@
+import { z } from 'zod';
+export declare const ConfigureIAMInputSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    userEmail: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    projectId: string;
+    userEmail: string;
+}, {
+    projectId: string;
+    userEmail: string;
+}>;
+export type ConfigureIAMInput = z.infer<typeof ConfigureIAMInputSchema>;
+export declare const EnableAPIInputSchema: z.ZodObject<{
+    projectId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    projectId: string;
+}, {
+    projectId: string;
+}>;
+export type EnableAPIInput = z.infer<typeof EnableAPIInputSchema>;
+export declare const TestConnectionInputSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    accessToken: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    projectId: string;
+    accessToken: string;
+}, {
+    projectId: string;
+    accessToken: string;
+}>;
+export type TestConnectionInput = z.infer<typeof TestConnectionInputSchema>;
+export declare const StitchErrorCode: z.ZodEnum<["IAM_CONFIG_FAILED", "API_ENABLE_FAILED", "CONNECTION_TEST_FAILED", "PERMISSION_DENIED", "UNKNOWN_ERROR"]>;
+export declare const IAMConfigSuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        role: z.ZodString;
+        member: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        role: string;
+        member: string;
+    }, {
+        role: string;
+        member: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        role: string;
+        member: string;
+    };
+}, {
+    success: true;
+    data: {
+        role: string;
+        member: string;
+    };
+}>;
+export declare const IAMConfigFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["IAM_CONFIG_FAILED", "API_ENABLE_FAILED", "CONNECTION_TEST_FAILED", "PERMISSION_DENIED", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+        recoverable: z.ZodBoolean;
+        details: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    }, {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    };
+}, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    };
+}>;
+export type IAMConfigResult = z.infer<typeof IAMConfigSuccess> | z.infer<typeof IAMConfigFailure>;
+export declare const APIEnableSuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        api: z.ZodString;
+        enabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        api: string;
+        enabled: boolean;
+    }, {
+        api: string;
+        enabled: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        api: string;
+        enabled: boolean;
+    };
+}, {
+    success: true;
+    data: {
+        api: string;
+        enabled: boolean;
+    };
+}>;
+export declare const APIEnableFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["IAM_CONFIG_FAILED", "API_ENABLE_FAILED", "CONNECTION_TEST_FAILED", "PERMISSION_DENIED", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+        recoverable: z.ZodBoolean;
+        details: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    }, {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    };
+}, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    };
+}>;
+export type APIEnableResult = z.infer<typeof APIEnableSuccess> | z.infer<typeof APIEnableFailure>;
+export declare const ConnectionTestSuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        connected: z.ZodBoolean;
+        statusCode: z.ZodNumber;
+        response: z.ZodOptional<z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        connected: boolean;
+        statusCode: number;
+        response?: any;
+    }, {
+        connected: boolean;
+        statusCode: number;
+        response?: any;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        connected: boolean;
+        statusCode: number;
+        response?: any;
+    };
+}, {
+    success: true;
+    data: {
+        connected: boolean;
+        statusCode: number;
+        response?: any;
+    };
+}>;
+export declare const ConnectionTestFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["IAM_CONFIG_FAILED", "API_ENABLE_FAILED", "CONNECTION_TEST_FAILED", "PERMISSION_DENIED", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+        recoverable: z.ZodBoolean;
+        details: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    }, {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    };
+}, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "IAM_CONFIG_FAILED" | "API_ENABLE_FAILED" | "CONNECTION_TEST_FAILED" | "PERMISSION_DENIED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+        details?: string | undefined;
+    };
+}>;
+export type ConnectionTestResult = z.infer<typeof ConnectionTestSuccess> | z.infer<typeof ConnectionTestFailure>;
+export interface StitchService {
+    /**
+     * Configure IAM permissions for Stitch API
+     */
+    configureIAM(input: ConfigureIAMInput): Promise<IAMConfigResult>;
+    /**
+     * Enable Stitch API for the project
+     */
+    enableAPI(input: EnableAPIInput): Promise<APIEnableResult>;
+    /**
+    * Test the connection to the Stitch API
+     */
+    testConnection(input: TestConnectionInput): Promise<ConnectionTestResult>;
+    /**
+     * Check if a user has a specific IAM role on a project
+     */
+    checkIAMRole(input: {
+        projectId: string;
+        userEmail: string;
+    }): Promise<boolean>;
+    /**
+     * Check if the Stitch API is enabled for a project
+     */
+    checkAPIEnabled(input: {
+        projectId: string;
+    }): Promise<boolean>;
+}

package/dist/src/services/stitch/spec.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/ui/spinner.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Wrapper for ora spinner with consistent styling
+ */
+export declare class Spinner {
+    private spinner;
+    start(message: string): void;
+    succeed(message: string): void;
+    fail(message: string): void;
+    stop(): void;
+}
+export declare function createSpinner(): Spinner;

package/dist/src/ui/theme.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Theme colors matching the shell script aesthetic
+ */
+export declare const theme: {
+    blue: import("chalk").ChalkInstance;
+    green: import("chalk").ChalkInstance;
+    gray: import("chalk").ChalkInstance;
+    red: import("chalk").ChalkInstance;
+    yellow: import("chalk").ChalkInstance;
+    cyan: import("chalk").ChalkInstance;
+    bgDark: import("chalk").ChalkInstance;
+};
+export declare const icons: {
+    success: string;
+    error: string;
+    info: string;
+    warning: string;
+};

package/dist/src/ui/wizard.d.ts

@@ -0,0 +1,24 @@
+export type McpClient = 'antigravity' | 'vscode' | 'cursor' | 'claude-code' | 'gemini-cli';
+/**
+ * Prompt user to select their MCP client
+ */
+export declare function promptMcpClient(): Promise<McpClient>;
+/**
+ * Prompt user to select from a list of options
+ */
+export declare function promptSelect<T extends string>(message: string, choices: Array<{
+    name: string;
+    value: T;
+}>): Promise<T>;
+/**
+ * Prompt user to enter text
+ */
+export declare function promptInput(message: string, defaultValue?: string): Promise<string>;
+/**
+ * Prompt user for confirmation
+ */
+export declare function promptConfirm(message: string, defaultValue?: boolean): Promise<boolean>;
+/**
+ * Prompt user to select transport type
+ */
+export declare function promptTransportType(): Promise<'http' | 'stdio'>;

package/dist/tests/mocks/shell.d.ts

@@ -0,0 +1,2 @@
+import type { ShellResult } from '../../src/platform/shell.js';
+export declare const mockExecCommand: import("bun:test").Mock<(command: string[], options?: any) => Promise<ShellResult>>;

package/dist/ui/spinner.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Wrapper for ora spinner with consistent styling
+ */
+export declare class Spinner {
+    private spinner;
+    start(message: string): void;
+    succeed(message: string): void;
+    fail(message: string): void;
+    stop(): void;
+}
+export declare function createSpinner(): Spinner;

package/dist/ui/theme.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Theme colors matching the shell script aesthetic
+ */
+export declare const theme: {
+    blue: import("chalk").ChalkInstance;
+    green: import("chalk").ChalkInstance;
+    gray: import("chalk").ChalkInstance;
+    red: import("chalk").ChalkInstance;
+    yellow: import("chalk").ChalkInstance;
+    cyan: import("chalk").ChalkInstance;
+    bgDark: import("chalk").ChalkInstance;
+};
+export declare const icons: {
+    success: string;
+    error: string;
+    info: string;
+    warning: string;
+};