byterover-cli 0.2.1 → 0.3.0

package/dist/commands/space/switch.js

@@ -1,18 +1,33 @@
-import { select } from '@inquirer/prompts';
+import { search, select } from '@inquirer/prompts';
 import { Command, ux } from '@oclif/core';
 import { getCurrentConfig } from '../../config/environment.js';
 import { BRV_DIR, PROJECT_CONFIG_FILE } from '../../constants.js';
+import { AGENT_VALUES } from '../../core/domain/entities/agent.js';
 import { BrvConfig } from '../../core/domain/entities/brv-config.js';
+import { ExitCode, ExitError, exitWithCode } from '../../infra/cipher/exit-codes.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';
 import { HttpTeamService } from '../../infra/team/http-team-service.js';
+import { WorkspaceDetectorService } from '../../infra/workspace/workspace-detector-service.js';
 export default class SpaceSwitch extends Command {
     static description = `Switch to a different team or space (updates ${BRV_DIR}/${PROJECT_CONFIG_FILE})`;
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '# Shows current configuration, then prompts for new team/space selection',
     ];
+    async catch(error) {
+        // Check if error is ExitError (message already displayed)
+        if (error instanceof ExitError) {
+            return;
+        }
+        // Backwards compatibility: also check oclif.exit property
+        if (error.oclif?.exit !== undefined) {
+            return;
+        }
+        // For unexpected errors, show the message
+        this.error(error instanceof Error ? error.message : 'Switch failed');
+    }
     createServices() {
         const envConfig = getCurrentConfig();
         return {
@@ -26,6 +41,35 @@ export default class SpaceSwitch extends Command {
             tokenStore: new KeychainTokenStore(),
         };
     }
+    detectWorkspacesForAgent(agent) {
+        const detector = new WorkspaceDetectorService();
+        const result = detector.detectWorkspaces(agent);
+        return {
+            chatLogPath: result.chatLogPath,
+            cwd: result.cwd,
+        };
+    }
+    /**
+     * Prompts the user to select an agent.
+     * This method is protected to allow test overrides.
+     * @returns The selected agent
+     */
+    async promptForAgentSelection() {
+        const AGENTS = AGENT_VALUES.map((agent) => ({
+            name: agent,
+            value: agent,
+        }));
+        const answer = await search({
+            message: 'Which agent you are using (type to search):',
+            async source(input) {
+                if (!input)
+                    return AGENTS;
+                return AGENTS.filter((agent) => agent.name.toLowerCase().includes(input.toLowerCase()) ||
+                    agent.value.toLowerCase().includes(input.toLowerCase()));
+            },
+        });
+        return answer;
+    }
     async promptForSpaceSelection(spaces) {
         const selectedSpaceId = await select({
             choices: spaces.map((space) => ({
@@ -36,7 +80,7 @@ export default class SpaceSwitch extends Command {
         });
         const selectedSpace = spaces.find((space) => space.id === selectedSpaceId);
         if (!selectedSpace) {
-            this.error('Space selection failed');
+            exitWithCode(ExitCode.VALIDATION_ERROR, 'Space selection failed');
         }
         return selectedSpace;
     }
@@ -50,62 +94,67 @@ export default class SpaceSwitch extends Command {
         });
         const selectedTeam = teams.find((team) => team.id === selectedTeamId);
         if (!selectedTeam) {
-            this.error('Team selection failed');
+            exitWithCode(ExitCode.VALIDATION_ERROR, 'Team selection failed');
         }
         return selectedTeam;
     }
     async run() {
-        try {
-            const { projectConfigStore, spaceService, teamService, tokenStore } = this.createServices();
-            // Check project initialization (MUST exist for switch)
-            const currentConfig = await projectConfigStore.read();
-            if (currentConfig === undefined) {
-                this.error('Project not initialized. Run "brv init" first.');
-            }
-            // Show current configuration
-            this.log('Current configuration:');
-            this.log(`  Team: ${currentConfig.teamName}`);
-            this.log(`  Space: ${currentConfig.spaceName}`);
-            this.log();
-            // Validate authentication
-            const token = await tokenStore.load();
-            if (token === undefined) {
-                this.error('Not authenticated. Please run "brv login" first.');
-            }
-            if (!token.isValid()) {
-                this.error('Authentication token expired. Please run "brv login" again.');
-            }
-            // Fetch all teams
-            ux.action.start('Fetching all teams');
-            const teamResult = await teamService.getTeams(token.accessToken, token.sessionKey, { fetchAll: true });
-            ux.action.stop();
-            if (teamResult.teams.length === 0) {
-                this.error('No teams found. Please create a team in the ByteRover dashboard first.');
-            }
-            // Prompt for team selection
-            this.log();
-            const selectedTeam = await this.promptForTeamSelection(teamResult.teams);
-            // Fetch spaces for selected team
-            ux.action.start('Fetching all spaces');
-            const spaceResult = await spaceService.getSpaces(token.accessToken, token.sessionKey, selectedTeam.id, {
-                fetchAll: true,
-            });
-            ux.action.stop();
-            if (spaceResult.spaces.length === 0) {
-                this.error(`No spaces found in team "${selectedTeam.getDisplayName()}". Please create a space in the ByteRover dashboard first.`);
-            }
-            // Prompt for space selection
-            this.log();
-            const selectedSpace = await this.promptForSpaceSelection(spaceResult.spaces);
-            // Update configuration
-            const newConfig = BrvConfig.fromSpace(selectedSpace);
-            await projectConfigStore.write(newConfig);
-            // Display success
-            this.log(`\n✓ Successfully switched to space: ${selectedSpace.getDisplayName()}`);
-            this.log(`✓ Configuration updated in: ${BRV_DIR}/${PROJECT_CONFIG_FILE}`);
+        const { projectConfigStore, spaceService, teamService, tokenStore } = this.createServices();
+        // Check project initialization (MUST exist for switch)
+        const currentConfig = await projectConfigStore.read();
+        if (!currentConfig) {
+            exitWithCode(ExitCode.VALIDATION_ERROR, 'Project not initialized. Please run "brv init" first.');
+        }
+        // Show current configuration
+        this.log('Current configuration:');
+        this.log(`  Team: ${currentConfig.teamName}`);
+        this.log(`  Space: ${currentConfig.spaceName}`);
+        this.log();
+        // Validate authentication
+        const token = await tokenStore.load();
+        if (!token) {
+            exitWithCode(ExitCode.VALIDATION_ERROR, 'Not authenticated. Please run "brv login" first.');
+        }
+        if (!token.isValid()) {
+            exitWithCode(ExitCode.VALIDATION_ERROR, 'Authentication token expired. Please run "brv login" again.');
         }
-        catch (error) {
-            this.error(error instanceof Error ? error.message : 'Switch failed');
+        // Fetch all teams
+        ux.action.start('Fetching all teams');
+        const teamResult = await teamService.getTeams(token.accessToken, token.sessionKey, { fetchAll: true });
+        ux.action.stop();
+        if (teamResult.teams.length === 0) {
+            exitWithCode(ExitCode.VALIDATION_ERROR, 'No teams found. Please create a team in the ByteRover dashboard first.');
         }
+        // Prompt for team selection
+        this.log();
+        const selectedTeam = await this.promptForTeamSelection(teamResult.teams);
+        // Fetch spaces for selected team
+        ux.action.start('Fetching all spaces');
+        const spaceResult = await spaceService.getSpaces(token.accessToken, token.sessionKey, selectedTeam.id, {
+            fetchAll: true,
+        });
+        ux.action.stop();
+        if (spaceResult.spaces.length === 0) {
+            exitWithCode(ExitCode.VALIDATION_ERROR, `No spaces found in team "${selectedTeam.getDisplayName()}". Please create a space in the ByteRover dashboard first.`);
+        }
+        // Prompt for space selection
+        this.log();
+        const selectedSpace = await this.promptForSpaceSelection(spaceResult.spaces);
+        // Prompt for agent selection
+        this.log();
+        const selectedAgent = await this.promptForAgentSelection();
+        this.log();
+        const { chatLogPath, cwd } = this.detectWorkspacesForAgent(selectedAgent);
+        // Update configuration
+        const newConfig = BrvConfig.fromSpace({
+            chatLogPath,
+            cwd,
+            ide: selectedAgent,
+            space: selectedSpace,
+        });
+        await projectConfigStore.write(newConfig);
+        // Display success
+        this.log(`\n✓ Successfully switched to space: ${selectedSpace.getDisplayName()}`);
+        this.log(`✓ Configuration updated in: ${BRV_DIR}/${PROJECT_CONFIG_FILE}`);
     }
 }

package/dist/commands/status.d.ts

@@ -1,5 +1,6 @@
 import { Command } from '@oclif/core';
-import type { IPlaybookStore } from '../core/interfaces/i-playbook-store.js';
+import type { IContextTreeService } from '../core/interfaces/i-context-tree-service.js';
+import type { IContextTreeSnapshotService } from '../core/interfaces/i-context-tree-snapshot-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';
@@ -12,8 +13,10 @@ export default class Status extends Command {
     static flags: {
         format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
+    catch(error: Error): Promise<void>;
     protected createServices(): {
-        playbookStore: IPlaybookStore;
+        contextTreeService: IContextTreeService;
+        contextTreeSnapshotService: IContextTreeSnapshotService;
         projectConfigStore: IProjectConfigStore;
         tokenStore: ITokenStore;
         trackingService: ITrackingService;

package/dist/commands/status.js

@@ -1,15 +1,18 @@
 import { Args, Command, Flags } from '@oclif/core';
 import chalk from 'chalk';
-import { ACE_DIR, BRV_DIR, BULLETS_DIR } from '../constants.js';
-import { FilePlaybookStore } from '../infra/ace/file-playbook-store.js';
+import { join } from 'node:path';
+import { BRV_DIR, CONTEXT_TREE_DIR } from '../constants.js';
 import { ProjectConfigStore } from '../infra/config/file-config-store.js';
+import { FileContextTreeService } from '../infra/context-tree/file-context-tree-service.js';
+import { FileContextTreeSnapshotService } from '../infra/context-tree/file-context-tree-snapshot-service.js';
 import { KeychainTokenStore } from '../infra/storage/keychain-token-store.js';
 import { MixpanelTrackingService } from '../infra/tracking/mixpanel-tracking-service.js';
+import { getErrorMessage } from '../utils/error-helpers.js';
 export default class Status extends Command {
     static args = {
         directory: Args.string({ description: 'Project directory (defaults to current directory)', required: false }),
     };
-    static description = 'Show CLI status and project information. Display local ACE context (ACE playbook) managed by ByteRover CLI';
+    static description = 'Show CLI status and project information. Display local context tree managed by ByteRover CLI';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
         '# Check status after login:\n<%= config.bin %> login\n<%= config.bin %> <%= command.id %>',
@@ -26,19 +29,25 @@ export default class Status extends Command {
             options: ['table', 'json'],
         }),
     };
+    // Override catch to prevent oclif from displaying errors again
+    async catch(error) {
+        // Status command should always succeed and just show status
+        // Any errors are already handled and logged in run()
+        throw error;
+    }
     createServices() {
         const tokenStore = new KeychainTokenStore();
         const trackingService = new MixpanelTrackingService(tokenStore);
         return {
-            playbookStore: new FilePlaybookStore(),
+            contextTreeService: new FileContextTreeService(),
+            contextTreeSnapshotService: new FileContextTreeSnapshotService(),
             projectConfigStore: new ProjectConfigStore(),
             tokenStore,
             trackingService,
         };
     }
     async run() {
-        const { playbookStore, projectConfigStore, tokenStore } = this.createServices();
-        const { args, flags } = await this.parse(Status);
+        const { contextTreeService, contextTreeSnapshotService, projectConfigStore, tokenStore } = this.createServices();
         this.log(`CLI Version: ${this.config.version}`);
         try {
             const token = await tokenStore.load();
@@ -54,7 +63,7 @@ export default class Status extends Command {
         }
         catch (error) {
             this.log('Status: Unable to check authentication status');
-            this.warn(`Warning: ${error.message}`);
+            this.warn(`Warning: ${getErrorMessage(error)}`);
         }
         const cwd = process.cwd();
         this.log(`Current Directory: ${cwd}`);
@@ -75,41 +84,42 @@ export default class Status extends Command {
         }
         catch (error) {
             this.log('Project Status: Unable to read project configuration');
-            this.warn(`Warning: ${error.message}`);
+            this.warn(`Warning: ${getErrorMessage(error)}`);
         }
+        // Context tree status
         try {
-            const playbook = await playbookStore.load(args.directory);
-            if (!playbook) {
-                this.error('Playbook not found. Run `brv init` to initialize.');
+            const contextTreeExists = await contextTreeService.exists();
+            if (!contextTreeExists) {
+                this.log('Context Tree: Not initialized');
+                return;
             }
-            // Display based on format
-            if (flags.format === 'json') {
-                return this.log(JSON.stringify(playbook.toJson(), null, 2));
+            const hasSnapshot = await contextTreeSnapshotService.hasSnapshot();
+            // Auto-create empty snapshot if none exists (all files will show as "added")
+            if (!hasSnapshot) {
+                await contextTreeSnapshotService.initEmptySnapshot();
             }
-            // Display file URLs like git status
-            const bullets = playbook.getBullets();
-            const sections = playbook.getSections();
-            if (bullets.length === 0) {
-                this.log('Playbook is empty. Use "brv add" commands to add knowledge.');
+            const changes = await contextTreeSnapshotService.getChanges();
+            const hasChanges = changes.added.length > 0 || changes.modified.length > 0 || changes.deleted.length > 0;
+            if (!hasChanges) {
+                this.log('Context Tree: No changes');
                 return;
             }
-            this.log(`\nMemory not pushed to cloud:`);
-            for (const section of sections) {
-                // Space between sections
-                this.log(' ');
-                // Section title
-                this.log(`# ${section}`);
-                const sectionBullets = playbook.getBulletsInSection(section);
-                for (const bullet of sectionBullets) {
-                    const relativePath = `${BRV_DIR}/${ACE_DIR}/${BULLETS_DIR}/${bullet.id}.md`;
-                    // Display like git status: red path
-                    this.log(`  ${chalk.red(relativePath)}`);
-                }
+            const contextTreeRelPath = join(BRV_DIR, CONTEXT_TREE_DIR);
+            const formatPath = (file) => join(contextTreeRelPath, file);
+            // Build unified list with status, sort by path ascending
+            const allChanges = [
+                ...changes.modified.map((f) => ({ color: chalk.red, path: f, status: 'modified:' })),
+                ...changes.added.map((f) => ({ color: chalk.red, path: f, status: 'new file:' })),
+                ...changes.deleted.map((f) => ({ color: chalk.red, path: f, status: 'deleted:' })),
+            ].sort((a, b) => a.path.localeCompare(b.path));
+            this.log('Context Tree Changes:');
+            for (const change of allChanges) {
+                this.log(`\t${change.color(`${change.status.padEnd(10)} ${formatPath(change.path)}`)}`);
             }
-            this.log(`\nUse "brv push" to push playbook to ByteRover memory storage.`);
         }
         catch (error) {
-            this.error(error instanceof Error ? error.message : 'Failed to load playbook statistics');
+            this.log('Context Tree: Unable to check status');
+            this.warn(`Warning: ${error instanceof Error ? error.message : 'Context Tree unable to check status'}`);
         }
     }
 }

package/dist/commands/watch.d.ts

@@ -0,0 +1,23 @@
+import { Command } from '@oclif/core';
+import type { IFileWatcherService } from '../core/interfaces/i-file-watcher-service.js';
+import type { IProjectConfigStore } from '../core/interfaces/i-project-config-store.js';
+export default class Watch extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        clean: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        debounce: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        paths: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static hidden: boolean;
+    private lastParseTime;
+    private parsingInProgress;
+    private pendingParse;
+    protected createServices(): {
+        fileWatcherService: IFileWatcherService;
+        projectConfigStore: IProjectConfigStore;
+    };
+    run(): Promise<void>;
+    protected waitForShutdownSignal(): Promise<void>;
+    private triggerParsing;
+}

package/dist/commands/watch.js

@@ -0,0 +1,171 @@
+import { Command, Flags } from '@oclif/core';
+import { isDevelopment } from '../config/environment.js';
+import { ProjectConfigStore } from '../infra/config/file-config-store.js';
+import { CleanParserServiceFactory } from '../infra/parsers/clean/clean-parser-service-factory.js';
+import { RawParserServiceFactory } from '../infra/parsers/raw/raw-parser-service-factory.js';
+import { FileWatcherService } from '../infra/watcher/file-watcher-service.js';
+export default class Watch extends Command {
+    static description = 'Watch file system directories for changes and trigger parsing pipeline [Development only]';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --paths ./agent-logs',
+        '<%= config.bin %> <%= command.id %> --paths ./logs,./outputs,./workspace',
+        '<%= config.bin %> <%= command.id %> -p ./src,./lib',
+        '# Use chat log path from config (if IDE was configured during init):',
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        clean: Flags.boolean({
+            allowNo: true,
+            default: true,
+            description: 'Run clean parsing after raw parsing (default: true)',
+        }),
+        debounce: Flags.integer({
+            default: 2000,
+            description: 'Debounce time in milliseconds before triggering parsing (default: 2000)',
+        }),
+        paths: Flags.string({
+            char: 'p',
+            description: 'Comma-separated list of directories to watch (defaults to configured chat log path)',
+            required: false,
+        }),
+    };
+    static hidden = !isDevelopment();
+    lastParseTime = 0;
+    parsingInProgress = false;
+    pendingParse = false;
+    createServices() {
+        return {
+            fileWatcherService: new FileWatcherService(),
+            projectConfigStore: new ProjectConfigStore(),
+        };
+    }
+    async run() {
+        if (!isDevelopment()) {
+            this.error('This command is only available in development environment');
+        }
+        const { flags } = await this.parse(Watch);
+        const { fileWatcherService, projectConfigStore } = this.createServices();
+        let paths = [];
+        let ideConfig = null;
+        // Use explicit paths if provided
+        if (flags.paths) {
+            paths = flags.paths.split(',').map((p) => p.trim());
+        }
+        else {
+            // Try to load chat log path from config
+            try {
+                const configExists = await projectConfigStore.exists();
+                if (configExists) {
+                    const config = await projectConfigStore.read();
+                    if (config?.chatLogPath && config?.ide) {
+                        paths = [config.chatLogPath];
+                        ideConfig = config.ide;
+                        this.log(`ℹ Using chat log path from config (${config.ide})`);
+                    }
+                }
+            }
+            catch {
+                // Silently ignore config loading errors
+            }
+            if (paths.length === 0) {
+                this.error('No paths specified. Either:\n' +
+                    '  1. Use --paths flag: brv watch --paths ./logs,./outputs\n' +
+                    '  2. Run "brv init" to configure IDE and detect workspaces');
+            }
+        }
+        try {
+            // Set up file event handler with parsing pipeline
+            fileWatcherService.setFileEventHandler(async (event) => {
+                this.log(`[${event.type}] ${event.path}`);
+                // Only trigger parsing if IDE is configured
+                if (ideConfig && (event.type === 'add' || event.type === 'change' || event.type === 'unlink')) {
+                    this.pendingParse = true;
+                    // Debounce parsing to avoid too frequent triggers
+                    if (!this.parsingInProgress && Date.now() - this.lastParseTime > flags.debounce) {
+                        this.triggerParsing(ideConfig, paths[0]).catch((error) => {
+                            this.warn(`⚠️ Parsing error: ${error instanceof Error ? error.message : String(error)}`);
+                        });
+                    }
+                }
+            });
+            await fileWatcherService.start(paths);
+            this.log(`\n🔍 Watching paths: ${paths.join(', ')}`);
+            if (ideConfig) {
+                this.log(`📊 Parsing pipeline enabled for: ${ideConfig}`);
+            }
+            this.log('Press Ctrl+C to stop...\n');
+            await this.waitForShutdownSignal();
+        }
+        catch (error) {
+            this.error(error instanceof Error ? error.message : 'Unknown Error');
+        }
+        finally {
+            await fileWatcherService.stop();
+        }
+    }
+    async waitForShutdownSignal() {
+        return new Promise((resolve) => {
+            const handleSignal = () => {
+                this.log('\nShutting down watcher...');
+                process.off('SIGINT', handleSignal);
+                process.off('SIGTERM', handleSignal);
+                resolve();
+            };
+            process.on('SIGINT', handleSignal);
+            process.on('SIGTERM', handleSignal);
+        });
+    }
+    async triggerParsing(ide, chatLogPath) {
+        if (this.parsingInProgress) {
+            return;
+        }
+        this.parsingInProgress = true;
+        this.pendingParse = false;
+        this.lastParseTime = Date.now();
+        try {
+            // Normalize IDE name for factory
+            // Validate IDE is supported
+            if (!RawParserServiceFactory.isSupported(ide)) {
+                this.warn(`⚠️ Unsupported IDE: ${ide}`);
+                return;
+            }
+            this.log('\n📥 Parsing triggered...');
+            // Raw parsing phase
+            let isRawSuccess = false;
+            try {
+                // Cast is safe because we already validated with isSupported()
+                isRawSuccess = await RawParserServiceFactory.parseConversations(ide, chatLogPath);
+            }
+            catch (error) {
+                this.warn(`⚠️ Raw parsing error: ${error instanceof Error ? error.message : String(error)}`);
+                return;
+            }
+            // Clean parsing phase (if enabled)
+            const { flags } = await this.parse(Watch);
+            if (isRawSuccess && flags.clean) {
+                try {
+                    const rawOutputDir = `${process.cwd()}/.brv/logs/${ide}/raw`;
+                    const cleanSessions = await CleanParserServiceFactory.parseConversations(ide, rawOutputDir);
+                    if (cleanSessions.length > 0) {
+                        this.log('✅ Clean parsing complete\n');
+                    }
+                    else {
+                        this.warn('⚠️ Clean parsing failed');
+                    }
+                }
+                catch (error) {
+                    this.warn(`⚠️ Clean parsing error: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        finally {
+            this.parsingInProgress = false;
+            // If more files were added while parsing, queue another parse
+            if (this.pendingParse) {
+                this.triggerParsing(ide, chatLogPath).catch((error) => {
+                    this.warn(`⚠️ Parsing error: ${error instanceof Error ? error.message : String(error)}`);
+                });
+            }
+        }
+    }
+}

package/dist/config/auth.config.js

@@ -23,8 +23,20 @@ export const getAuthConfig = async (discoveryService) => {
         // Fallback to hardcoded environment-specific URLs
         authorizationUrl = envConfig.authorizationUrl;
         tokenUrl = envConfig.tokenUrl;
-        // Warn user about fallback
-        console.warn(`Warning: OIDC discovery failed, using fallback URLs for ${ENVIRONMENT} environment.`, error instanceof Error ? error.message : 'Unknown error');
+        // Warn user about fallback with user-friendly error message
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        const isNetworkError = errorMessage.includes('ENOTFOUND') ||
+            errorMessage.includes('ECONNREFUSED') ||
+            errorMessage.includes('ETIMEDOUT') ||
+            errorMessage.includes('getaddrinfo') ||
+            errorMessage.includes('network');
+        if (isNetworkError) {
+            // Throw error and let command handle exit
+            throw new Error('❌ Network error: Unable to connect to ByteRover servers. Please check your internet connection and try again.');
+        }
+        else {
+            console.warn(`Warning: OIDC discovery failed, using fallback URLs for ${ENVIRONMENT} environment.`, errorMessage);
+        }
     }
     return {
         authorizationUrl,

package/dist/config/context-tree-domains.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Domain configurations for the context tree structure.
+ * Each domain represents a specific area of knowledge in the project.
+ */
+export interface DomainConfig {
+    description: string;
+    name: string;
+}
+/**
+ * Predefined domains that will be scaffolded during project initialization.
+ */
+export declare const CONTEXT_TREE_DOMAINS: DomainConfig[];

package/dist/config/context-tree-domains.js

@@ -0,0 +1,29 @@
+/**
+ * Predefined domains that will be scaffolded during project initialization.
+ */
+export const CONTEXT_TREE_DOMAINS = [
+    {
+        description: 'Ensure all code follows style guidelines and quality standards',
+        name: 'code_style',
+    },
+    {
+        description: 'UI libraries, themes, and design guidelines',
+        name: 'design',
+    },
+    {
+        description: 'Project structure, components, and related context',
+        name: 'structure',
+    },
+    {
+        description: 'Security and compliance information',
+        name: 'compliance',
+    },
+    {
+        description: 'Testing implementation context',
+        name: 'testing',
+    },
+    {
+        description: 'Bug fixing logic and procedures',
+        name: 'bug_fixes',
+    },
+];

package/dist/config/environment.d.ts

@@ -17,6 +17,7 @@ type EnvironmentConfig = {
     clientId: string;
     cogitApiBaseUrl: string;
     issuerUrl: string;
+    llmGrpcEndpoint: string;
     memoraApiBaseUrl: string;
     mixpanelToken: string;
     scopes: string[];
@@ -33,4 +34,9 @@ export declare const ENV_CONFIG: Record<Environment, EnvironmentConfig>;
  * @returns The environment configuration.
  */
 export declare const getCurrentConfig: () => EnvironmentConfig;
+/**
+ * Check if the current environment is development.
+ * @returns True if in development mode, false otherwise.
+ */
+export declare const isDevelopment: () => boolean;
 export {};