byterover-cli 0.1.0

package/dist/commands/login.js

@@ -0,0 +1,103 @@
+import { Command } from '@oclif/core';
+import { getAuthConfig } from '../config/auth.config.js';
+import { getCurrentConfig } from '../config/environment.js';
+import { AuthToken } from '../core/domain/entities/auth-token.js';
+import { DiscoveryError } from '../core/domain/errors/discovery-error.js';
+import { OAuthService } from '../infra/auth/oauth-service.js';
+import { OidcDiscoveryService } from '../infra/auth/oidc-discovery-service.js';
+import { SystemBrowserLauncher } from '../infra/browser/system-browser-launcher.js';
+import { CallbackHandler } from '../infra/http/callback-handler.js';
+import { KeychainTokenStore } from '../infra/storage/keychain-token-store.js';
+import { MixpanelTrackingService } from '../infra/tracking/mixpanel-tracking-service.js';
+import { HttpUserService } from '../infra/user/http-user-service.js';
+export default class Login extends Command {
+    static description = 'Authenticate with ByteRover using OAuth 2.0 + PKCE (opens browser for secure login, stores tokens in keychain)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '# After authentication expires, re-login:\n<%= config.bin %> <%= command.id %>',
+        '# Check authentication status after login:\n<%= config.bin %> <%= command.id %>\n<%= config.bin %> status',
+    ];
+    async createAuthService(discoveryService) {
+        const config = await getAuthConfig(discoveryService);
+        return new OAuthService(config);
+    }
+    createServices() {
+        const config = getCurrentConfig();
+        const tokenStore = new KeychainTokenStore();
+        const trackingService = new MixpanelTrackingService(tokenStore);
+        return {
+            browserLauncher: new SystemBrowserLauncher(),
+            callbackHandler: new CallbackHandler(),
+            discoveryService: new OidcDiscoveryService(),
+            tokenStore,
+            trackingService,
+            userService: new HttpUserService({ apiBaseUrl: config.apiBaseUrl }),
+        };
+    }
+    async run() {
+        const { browserLauncher, callbackHandler, discoveryService, tokenStore, trackingService, userService } = this.createServices();
+        try {
+            this.log('Starting authentication process...');
+            // Create auth service with discovered config
+            const authService = await this.createAuthService(discoveryService);
+            // Start callback server
+            await callbackHandler.start();
+            // Get port and build redirect URI
+            const port = callbackHandler.getPort();
+            if (!port) {
+                throw new Error('Failed to get callback server port');
+            }
+            const redirectUri = `http://localhost:${port}/callback`;
+            // Initiate authorization (generates PKCE parameters and state internally)
+            const authContext = authService.initiateAuthorization(redirectUri);
+            // Try to open browser
+            let browserOpened = false;
+            try {
+                await browserLauncher.open(authContext.authUrl);
+                browserOpened = true;
+            }
+            catch {
+                // Browser launch failed, will return URL to user
+            }
+            // If browser failed to open, display the URL for manual copy
+            if (!browserOpened) {
+                this.log('\nBrowser failed to open automatically.');
+                this.log('Please open this URL in your browser:');
+                this.log(authContext.authUrl);
+            }
+            try {
+                // Wait for callback with 5 minute timeout
+                const { code } = await callbackHandler.waitForCallback(authContext.state, 5 * 60 * 1000);
+                const authTokenData = await authService.exchangeCodeForToken(code, authContext, redirectUri);
+                const user = await userService.getCurrentUser(authTokenData.accessToken, authTokenData.sessionKey);
+                const authToken = new AuthToken({
+                    accessToken: authTokenData.accessToken,
+                    expiresAt: authTokenData.expiresAt,
+                    refreshToken: authTokenData.refreshToken,
+                    sessionKey: authTokenData.sessionKey,
+                    tokenType: authTokenData.tokenType,
+                    userEmail: user.email,
+                    userId: user.id,
+                });
+                await tokenStore.save(authToken);
+                // Track successful authentication
+                await trackingService.track('auth:signed_in');
+                this.log('Successfully authenticated!');
+            }
+            catch (error) {
+                this.error(error instanceof Error ? error.message : 'Authentication failed');
+            }
+        }
+        catch (error) {
+            if (error instanceof DiscoveryError) {
+                this.error(`Failed to configure authentication: ${error.message}\n` +
+                    'Please check your network connection and try again.');
+            }
+            this.error(error instanceof Error ? error.message : 'Authentication failed');
+        }
+        finally {
+            // Always cleanup server
+            await callbackHandler.stop();
+        }
+    }
+}

package/dist/commands/push.d.ts

@@ -0,0 +1,33 @@
+import { Command } from '@oclif/core';
+import type { AuthToken } from '../core/domain/entities/auth-token.js';
+import type { BrConfig } from '../core/domain/entities/br-config.js';
+import type { PresignedUrl } from '../core/domain/entities/presigned-url.js';
+import type { PresignedUrlsResponse } from '../core/domain/entities/presigned-urls-response.js';
+import type { IMemoryStorageService } from '../core/interfaces/i-memory-storage-service.js';
+import type { IPlaybookStore } from '../core/interfaces/i-playbook-store.js';
+import type { IProjectConfigStore } from '../core/interfaces/i-project-config-store.js';
+import type { ITokenStore } from '../core/interfaces/i-token-store.js';
+import { ITrackingService } from '../core/interfaces/i-tracking-service.js';
+export default class Push extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        branch: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected checkProjectInit(projectConfigStore: IProjectConfigStore): Promise<BrConfig>;
+    protected cleanUpLocalFiles(playbookStore: IPlaybookStore): Promise<void>;
+    protected confirmUpload(memoryService: IMemoryStorageService, token: AuthToken, projectConfig: BrConfig, requestId: string): Promise<void>;
+    protected createServices(): {
+        memoryService: IMemoryStorageService;
+        playbookStore: IPlaybookStore;
+        projectConfigStore: IProjectConfigStore;
+        tokenStore: ITokenStore;
+        trackingService: ITrackingService;
+    };
+    protected getPresignedUrls(memoryService: IMemoryStorageService, token: AuthToken, projectConfig: BrConfig): Promise<PresignedUrlsResponse>;
+    protected loadPlaybookContent(playbookStore: IPlaybookStore): Promise<string>;
+    run(): Promise<void>;
+    protected uploadFiles(memoryService: IMemoryStorageService, presignedUrls: ReadonlyArray<PresignedUrl>, playbookContent: string): Promise<void>;
+    protected validateAuth(tokenStore: ITokenStore): Promise<AuthToken>;
+    protected verifyPlaybookExists(playbookStore: IPlaybookStore): Promise<void>;
+}

package/dist/commands/push.js

@@ -0,0 +1,150 @@
+import { Command, Flags, ux } from '@oclif/core';
+import { join } from 'node:path';
+import { getCurrentConfig } from '../config/environment.js';
+import { ACE_DIR, BR_DIR, DEFAULT_BRANCH, DELTAS_DIR, EXECUTOR_OUTPUTS_DIR, REFLECTIONS_DIR } from '../constants.js';
+import { FilePlaybookStore } from '../infra/ace/file-playbook-store.js';
+import { ProjectConfigStore } from '../infra/config/file-config-store.js';
+import { HttpMemoryStorageService } from '../infra/memory/http-memory-storage-service.js';
+import { KeychainTokenStore } from '../infra/storage/keychain-token-store.js';
+import { MixpanelTrackingService } from '../infra/tracking/mixpanel-tracking-service.js';
+import { clearDirectory } from '../utils/file-helpers.js';
+export default class Push extends Command {
+    static description = 'Push playbook to ByteRover memory storage and clean up local ACE files';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --branch develop',
+        '<%= config.bin %> <%= command.id %> -b feature-auth',
+    ];
+    static flags = {
+        branch: Flags.string({
+            // Can pass either --branch or -b
+            char: 'b',
+            default: DEFAULT_BRANCH,
+            description: 'ByteRover branch name (not Git branch)',
+        }),
+    };
+    async checkProjectInit(projectConfigStore) {
+        const projectConfig = await projectConfigStore.read();
+        if (projectConfig === undefined) {
+            this.error('Project not initialized. Run "br init" first.');
+        }
+        return projectConfig;
+    }
+    async cleanUpLocalFiles(playbookStore) {
+        this.log('\nCleaning up local files...');
+        // Clear playbook content
+        ux.action.start('  Clearing playbook');
+        await playbookStore.clear();
+        ux.action.stop('✓');
+        // Clean executor outputs
+        const baseDir = process.cwd();
+        const aceDir = join(baseDir, BR_DIR, ACE_DIR);
+        const executorOutputsDir = join(aceDir, EXECUTOR_OUTPUTS_DIR);
+        const reflectionsDir = join(aceDir, REFLECTIONS_DIR);
+        const deltasDir = join(aceDir, DELTAS_DIR);
+        ux.action.start('  Cleaning executor outputs');
+        const executorCount = await clearDirectory(executorOutputsDir);
+        ux.action.stop(`✓ (${executorCount} files removed)`);
+        // Clean reflections
+        ux.action.start('  Cleaning reflections');
+        const reflectionCount = await clearDirectory(reflectionsDir);
+        ux.action.stop(`✓ (${reflectionCount} files removed)`);
+        // Clean deltas
+        ux.action.start('  Cleaning deltas');
+        const deltaCount = await clearDirectory(deltasDir);
+        ux.action.stop(`✓ (${deltaCount} files removed)`);
+    }
+    async confirmUpload(memoryService, token, projectConfig, requestId) {
+        ux.action.start('Confirming upload');
+        await memoryService.confirmUpload({
+            accessToken: token.accessToken,
+            requestId,
+            sessionKey: token.sessionKey,
+            spaceId: projectConfig.spaceId,
+            teamId: projectConfig.teamId,
+        });
+        ux.action.stop('✓');
+    }
+    createServices() {
+        const envConfig = getCurrentConfig();
+        const tokenStore = new KeychainTokenStore();
+        const trackingService = new MixpanelTrackingService(tokenStore);
+        return {
+            memoryService: new HttpMemoryStorageService({
+                apiBaseUrl: envConfig.cogitApiBaseUrl,
+            }),
+            playbookStore: new FilePlaybookStore(),
+            projectConfigStore: new ProjectConfigStore(),
+            tokenStore,
+            trackingService,
+        };
+    }
+    async getPresignedUrls(memoryService, token, projectConfig) {
+        const { flags } = await this.parse(Push);
+        ux.action.start('Requesting upload URLs');
+        const response = await memoryService.getPresignedUrls({
+            accessToken: token.accessToken,
+            branch: flags.branch,
+            fileNames: ['playbook.json'],
+            sessionKey: token.sessionKey,
+            spaceId: projectConfig.spaceId,
+            teamId: projectConfig.teamId,
+        });
+        ux.action.stop();
+        return response;
+    }
+    async loadPlaybookContent(playbookStore) {
+        ux.action.start('Loading playbook');
+        const playbook = await playbookStore.load();
+        if (playbook === undefined) {
+            this.error('Failed to load playbook');
+        }
+        const playbookContent = playbook.dumps();
+        ux.action.stop();
+        return playbookContent;
+    }
+    async run() {
+        const { flags } = await this.parse(Push);
+        try {
+            const { memoryService, playbookStore, projectConfigStore, tokenStore, trackingService } = this.createServices();
+            await trackingService.track('mem:push');
+            const token = await this.validateAuth(tokenStore);
+            const projectConfig = await this.checkProjectInit(projectConfigStore);
+            await this.verifyPlaybookExists(playbookStore);
+            const response = await this.getPresignedUrls(memoryService, token, projectConfig);
+            const playbookContent = await this.loadPlaybookContent(playbookStore);
+            await this.uploadFiles(memoryService, response.presignedUrls, playbookContent);
+            await this.confirmUpload(memoryService, token, projectConfig, response.requestId);
+            await this.cleanUpLocalFiles(playbookStore);
+            // Success message
+            this.log('\n✓ Successfully pushed playbook to ByteRover memory storage!');
+            this.log(`  Branch: ${flags.branch}`);
+            this.log(`  Files uploaded: ${response.presignedUrls.length}`);
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : 'Push failed');
+        }
+    }
+    async uploadFiles(memoryService, presignedUrls, playbookContent) {
+        this.log('\nUploading files...');
+        ux.action.start('  Uploading files');
+        await Promise.all(presignedUrls.map((presignedUrl) => memoryService.uploadFile(presignedUrl.uploadUrl, playbookContent)));
+        ux.action.stop('✓');
+    }
+    async validateAuth(tokenStore) {
+        const token = await tokenStore.load();
+        if (token === undefined) {
+            this.error('Not authenticated. Run "br login" first.');
+        }
+        if (!token.isValid()) {
+            this.error('Authentication token expired. Run "br login" again.');
+        }
+        return token;
+    }
+    async verifyPlaybookExists(playbookStore) {
+        const playbookExists = await playbookStore.exists();
+        if (!playbookExists) {
+            this.error('Playbook not found. Run "br init" to create one.');
+        }
+    }
+}

package/dist/commands/retrieve.d.ts

@@ -0,0 +1,26 @@
+import { Command } from '@oclif/core';
+import type { AuthToken } from '../core/domain/entities/auth-token.js';
+import type { BrConfig } from '../core/domain/entities/br-config.js';
+import type { IMemoryRetrievalService } from '../core/interfaces/i-memory-retrieval-service.js';
+import type { IProjectConfigStore } from '../core/interfaces/i-project-config-store.js';
+import type { ITokenStore } from '../core/interfaces/i-token-store.js';
+import { ITrackingService } from '../core/interfaces/i-tracking-service.js';
+export default class Retrieve extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        compact: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'node-keys': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        query: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected checkProjectInt(projectConfigStore: IProjectConfigStore): Promise<BrConfig>;
+    protected createServices(): {
+        memoryService: IMemoryRetrievalService;
+        projectConfigStore: IProjectConfigStore;
+        tokenStore: ITokenStore;
+        trackingService: ITrackingService;
+    };
+    run(): Promise<void>;
+    protected validateAuth(tokenStore: ITokenStore): Promise<AuthToken>;
+    private buildJsonOutput;
+}

package/dist/commands/retrieve.js

@@ -0,0 +1,101 @@
+import { Command, Flags } from '@oclif/core';
+import { getCurrentConfig } from '../config/environment.js';
+import { ProjectConfigStore } from '../infra/config/file-config-store.js';
+import { HttpMemoryRetrievalService } from '../infra/memory/http-memory-retrieval-service.js';
+import { KeychainTokenStore } from '../infra/storage/keychain-token-store.js';
+import { MixpanelTrackingService } from '../infra/tracking/mixpanel-tracking-service.js';
+export default class Retrieve extends Command {
+    static description = 'Retrieve memories from ByteRover Memora service and output as JSON';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --query "authentication best practices"',
+        '<%= config.bin %> <%= command.id %> -q "error handling" -n "src/auth/login.ts,src/auth/oauth.ts"',
+        '<%= config.bin %> <%= command.id %> -q "database connection issues" --compact',
+    ];
+    static flags = {
+        compact: Flags.boolean({
+            default: false,
+            description: 'Output compact JSON (single line)',
+            required: false,
+        }),
+        'node-keys': Flags.string({
+            char: 'n',
+            description: 'Comma-separated list of node keys (file paths) to filter results',
+            required: false,
+        }),
+        query: Flags.string({
+            char: 'q',
+            description: 'Search query string',
+            required: true,
+        }),
+    };
+    async checkProjectInt(projectConfigStore) {
+        const isInitialized = await projectConfigStore.exists();
+        if (!isInitialized) {
+            this.error('Project is not initialized. Please run "br init" first.');
+        }
+        const config = await projectConfigStore.read();
+        if (!config) {
+            this.error('Failed to read project configuration.');
+        }
+        return config;
+    }
+    createServices() {
+        const envConfig = getCurrentConfig();
+        const tokenStore = new KeychainTokenStore();
+        const trackingService = new MixpanelTrackingService(tokenStore);
+        return {
+            memoryService: new HttpMemoryRetrievalService({
+                apiBaseUrl: envConfig.memoraApiBaseUrl,
+            }),
+            projectConfigStore: new ProjectConfigStore(),
+            tokenStore,
+            trackingService,
+        };
+    }
+    async run() {
+        const { flags } = await this.parse(Retrieve);
+        const { memoryService, projectConfigStore, tokenStore, trackingService } = this.createServices();
+        try {
+            const token = await this.validateAuth(tokenStore);
+            const projectConfig = await this.checkProjectInt(projectConfigStore);
+            // Initialize tracking service
+            await trackingService.track('mem:retrieve');
+            // Parse node-keys if provided
+            const nodeKeys = flags['node-keys'] ? flags['node-keys'].split(',').map((key) => key.trim()) : undefined;
+            // Call memory service
+            const result = await memoryService.retrieve({
+                accessToken: token.accessToken,
+                nodeKeys,
+                query: flags.query,
+                sessionKey: token.sessionKey,
+                spaceId: projectConfig.spaceId,
+            });
+            // Build and output JSON
+            const output = this.buildJsonOutput(result, flags.query, projectConfig.spaceName, nodeKeys);
+            const jsonString = flags.compact ? JSON.stringify(output) : JSON.stringify(output, null, 2);
+            this.log(jsonString);
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : 'Failed to retrieve memories');
+        }
+    }
+    async validateAuth(tokenStore) {
+        const token = await tokenStore.load();
+        if (token === undefined) {
+            this.error('Not authenticated. Please run "br auth login" first.');
+        }
+        if (!token.isValid()) {
+            this.error('Authentication token expired. Please run "br auth login" again.');
+        }
+        return token;
+    }
+    buildJsonOutput(result, query, spaceName, nodeKeys) {
+        return {
+            query,
+            spaceName,
+            ...(nodeKeys && nodeKeys.length > 0 && { nodeKeys }),
+            memories: result.memories.map((m) => m.toJson()),
+            relatedMemories: result.relatedMemories.map((m) => m.toJson()),
+        };
+    }
+}

package/dist/commands/space/list.d.ts

@@ -0,0 +1,22 @@
+import { Command } from '@oclif/core';
+import type { IProjectConfigStore } from '../../core/interfaces/i-project-config-store.js';
+import type { ISpaceService } from '../../core/interfaces/i-space-service.js';
+import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
+import { AuthToken } from '../../core/domain/entities/auth-token.js';
+export default class SpaceList extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        offset: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected createServices(): {
+        projectConfigStore: IProjectConfigStore;
+        spaceService: ISpaceService;
+        tokenStore: ITokenStore;
+    };
+    run(): Promise<void>;
+    protected validateAuth(tokenStore: ITokenStore): Promise<AuthToken>;
+}

package/dist/commands/space/list.js

@@ -0,0 +1,105 @@
+import { Command, Flags, ux } from '@oclif/core';
+import { getCurrentConfig } from '../../config/environment.js';
+import { ProjectConfigStore } from '../../infra/config/file-config-store.js';
+import { HttpSpaceService } from '../../infra/space/http-space-service.js';
+import { KeychainTokenStore } from '../../infra/storage/keychain-token-store.js';
+const DEFAULT_LIMIT = 50;
+const DEFAULT_OFFSET = 0;
+export default class SpaceList extends Command {
+    static description = 'List all spaces for the current team (requires project initialization)';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --all',
+        '<%= config.bin %> <%= command.id %> --limit 10',
+        '<%= config.bin %> <%= command.id %> --limit 10 --offset 20',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        all: Flags.boolean({
+            char: 'a',
+            default: false,
+            description: 'Fetch all spaces (may be slow for large teams)',
+        }),
+        json: Flags.boolean({
+            char: 'j',
+            default: false,
+            description: 'Output in JSON format',
+        }),
+        limit: Flags.integer({
+            char: 'l',
+            default: DEFAULT_LIMIT,
+            description: 'Maximum number of spaces to fetch',
+        }),
+        offset: Flags.integer({
+            char: 'o',
+            default: DEFAULT_OFFSET,
+            description: 'Number of spaces to skip',
+        }),
+    };
+    createServices() {
+        const envConfig = getCurrentConfig();
+        return {
+            projectConfigStore: new ProjectConfigStore(),
+            spaceService: new HttpSpaceService({ apiBaseUrl: envConfig.apiBaseUrl }),
+            tokenStore: new KeychainTokenStore(),
+        };
+    }
+    async run() {
+        try {
+            const { flags } = await this.parse(SpaceList);
+            const { projectConfigStore, spaceService, tokenStore } = this.createServices();
+            // Check project initialization
+            const projectConfig = await projectConfigStore.read();
+            if (projectConfig === undefined) {
+                this.error('Project not initialized. Run "br init" first.');
+            }
+            const token = await this.validateAuth(tokenStore);
+            // Fetch spaces for the team from project config
+            ux.action.start(`Fetching spaces for ${projectConfig.teamName}`);
+            const result = await spaceService.getSpaces(token.accessToken, token.sessionKey, projectConfig.teamId, flags.all ? { fetchAll: true } : { limit: flags.limit, offset: flags.offset });
+            ux.action.stop();
+            // Handle empty results
+            if (result.spaces.length === 0) {
+                this.log(`No spaces found in team "${projectConfig.teamName}".`);
+                return;
+            }
+            // Display results based on format
+            if (flags.json) {
+                this.log(JSON.stringify({
+                    showing: result.spaces.length,
+                    spaces: result.spaces.map((s) => s.toJson()),
+                    team: { id: projectConfig.teamId, name: projectConfig.teamName },
+                    total: result.total,
+                }, null, 2));
+                return;
+            }
+            // Human-readable format
+            this.log(`\nSpaces in team "${projectConfig.teamName}":\n`);
+            this.log(`Found ${result.spaces.length} space(s):\n`);
+            for (const [index, space] of result.spaces.entries()) {
+                this.log(`  ${index + 1}. ${space.getDisplayName()}`);
+            }
+            // Pagination warning
+            if (!flags.all && result.spaces.length < result.total) {
+                const remaining = result.total - result.spaces.length - flags.offset;
+                this.log(`\nShowing ${result.spaces.length} of ${result.total} spaces.`);
+                if (remaining > 0) {
+                    this.log('Use --all to fetch all spaces, or use --limit and --offset for pagination.');
+                }
+            }
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : 'Failed to list spaces');
+        }
+    }
+    async validateAuth(tokenStore) {
+        const token = await tokenStore.load();
+        if (token === undefined) {
+            this.error('Not authenticated. Please run "br login" first.');
+        }
+        if (!token.isValid()) {
+            this.error('Authentication token expired. Please run "br login" again.');
+        }
+        return token;
+    }
+}

package/dist/commands/space/switch.d.ts

@@ -0,0 +1,20 @@
+import { Command } from '@oclif/core';
+import type { Space } from '../../core/domain/entities/space.js';
+import type { Team } from '../../core/domain/entities/team.js';
+import type { IProjectConfigStore } from '../../core/interfaces/i-project-config-store.js';
+import type { ISpaceService } from '../../core/interfaces/i-space-service.js';
+import type { ITeamService } from '../../core/interfaces/i-team-service.js';
+import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
+export default class SpaceSwitch extends Command {
+    static description: string;
+    static examples: string[];
+    protected createServices(): {
+        projectConfigStore: IProjectConfigStore;
+        spaceService: ISpaceService;
+        teamService: ITeamService;
+        tokenStore: ITokenStore;
+    };
+    protected promptForSpaceSelection(spaces: Space[]): Promise<Space>;
+    protected promptForTeamSelection(teams: Team[]): Promise<Team>;
+    run(): Promise<void>;
+}