byterover-cli 0.3.5 → 0.4.1

package/dist/{commands/init.js → infra/usecase/init-use-case.js}

@@ -1,42 +1,42 @@
-import { confirm, search, select } from '@inquirer/prompts';
-import { Command, Flags, ux } from '@oclif/core';
 import { access, readFile, rm } from 'node:fs/promises';
 import { join } from 'node:path';
-import { getCurrentConfig } from '../config/environment.js';
-import { ACE_DIR, BRV_CONFIG_VERSION, BRV_DIR, DEFAULT_BRANCH, 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 { BrvConfigVersionError } from '../core/domain/errors/brv-config-version-error.js';
-import { HttpCogitPullService } from '../infra/cogit/http-cogit-pull-service.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 { FileContextTreeWriterService } from '../infra/context-tree/file-context-tree-writer-service.js';
-import { FsFileService } from '../infra/file/fs-file-service.js';
-import { AGENT_RULE_CONFIGS } from '../infra/rule/agent-rule-config.js';
-import { BRV_RULE_MARKERS, BRV_RULE_TAG } from '../infra/rule/constants.js';
-import { LegacyRuleDetector } from '../infra/rule/legacy-rule-detector.js';
-import { RuleTemplateService } from '../infra/rule/rule-template-service.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 { FsTemplateLoader } from '../infra/template/fs-template-loader.js';
-import { MixpanelTrackingService } from '../infra/tracking/mixpanel-tracking-service.js';
-import { WorkspaceDetectorService } from '../infra/workspace/workspace-detector-service.js';
-export default class Init extends Command {
-    static description = `Initialize a project with ByteRover (creates ${BRV_DIR}/${PROJECT_CONFIG_FILE} with team/space selection and initializes Context Tree)`;
-    static examples = [
-        '<%= config.bin %> <%= command.id %>',
-        '# Re-initialize if config exists (will show current config and exit):\n<%= config.bin %> <%= command.id %>',
-        '# Full workflow: login then initialize:\n<%= config.bin %> login\n<%= config.bin %> <%= command.id %>',
-    ];
-    static flags = {
-        force: Flags.boolean({
-            char: 'f',
-            default: false,
-            description: 'Force re-initialization without confirmation prompt',
-        }),
-    };
+import { getCurrentConfig } from '../../config/environment.js';
+import { ACE_DIR, BRV_CONFIG_VERSION, BRV_DIR, DEFAULT_BRANCH, 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 { BrvConfigVersionError } from '../../core/domain/errors/brv-config-version-error.js';
+import { AGENT_RULE_CONFIGS } from '../rule/agent-rule-config.js';
+import { BRV_RULE_MARKERS, BRV_RULE_TAG } from '../rule/constants.js';
+import { WorkspaceDetectorService } from '../workspace/workspace-detector-service.js';
+export class InitUseCase {
+    cogitPullService;
+    contextTreeService;
+    contextTreeSnapshotService;
+    contextTreeWriterService;
+    fileService;
+    legacyRuleDetector;
+    projectConfigStore;
+    spaceService;
+    teamService;
+    templateService;
+    terminal;
+    tokenStore;
+    trackingService;
+    constructor(options) {
+        this.cogitPullService = options.cogitPullService;
+        this.contextTreeService = options.contextTreeService;
+        this.contextTreeSnapshotService = options.contextTreeSnapshotService;
+        this.contextTreeWriterService = options.contextTreeWriterService;
+        this.fileService = options.fileService;
+        this.legacyRuleDetector = options.legacyRuleDetector;
+        this.projectConfigStore = options.projectConfigStore;
+        this.spaceService = options.spaceService;
+        this.teamService = options.teamService;
+        this.templateService = options.templateService;
+        this.terminal = options.terminal;
+        this.tokenStore = options.tokenStore;
+        this.trackingService = options.trackingService;
+    }
     async aceDirectoryExists(baseDir) {
         const dir = baseDir ?? process.cwd();
         const acePath = join(dir, BRV_DIR, ACE_DIR);
@@ -50,69 +50,40 @@ export default class Init extends Command {
     }
     async cleanupBeforeReInitialization() {
         const brvDir = join(process.cwd(), BRV_DIR);
-        this.log('\n Cleaning up existing ByteRover directory...');
-        ux.action.start(`  Removing ${BRV_DIR}/`);
+        this.terminal.log('\n Cleaning up existing ByteRover directory...');
+        this.terminal.actionStart(`  Removing ${BRV_DIR}/`);
         try {
             await rm(brvDir, { force: true, recursive: true });
-            ux.action.stop('✓');
+            this.terminal.actionStop('✓');
         }
         catch (error) {
-            ux.action.stop('✗');
-            throw new Error(`Failed to remove ${BRV_DIR}/: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            this.terminal.actionStop('✗');
+            const brvDirRemovalErr = `Failed to remove ${BRV_DIR}/: ${error instanceof Error ? error.message : 'Unknown error'}`;
+            await this.trackingService.track('init', { message: brvDirRemovalErr, status: 'error' });
+            throw new Error(brvDirRemovalErr);
         }
     }
     async confirmReInitialization(config) {
         if (this.isLegacyProjectConfig(config)) {
             const versionStatus = config.currentVersion === undefined ? 'missing' : `${config.currentVersion} → ${BRV_CONFIG_VERSION}`;
-            this.log(`\n⚠️  Project has an outdated configuration (version: ${versionStatus})`);
+            this.terminal.log(`\n⚠️  Project has an outdated configuration (version: ${versionStatus})`);
         }
         else {
-            this.log('\n Project is already initialized');
+            this.terminal.log('\n Project is already initialized');
         }
-        this.log(`  Team: ${config.teamName}`);
-        this.log(`  Space: ${config.spaceName}`);
-        this.log(`  Config: ${join(process.cwd(), BRV_DIR, PROJECT_CONFIG_FILE)}`);
-        this.log('\n Re-initializing will:');
-        this.log(`  - Remove the entire ${BRV_DIR}/ directory and all its contents`);
-        this.log('  - Allow you to select a new team/space');
-        this.log('  - Create a fresh configuration and Context Tree');
-        this.log('  - Regenerate rule instructions\n');
-        return confirm({
+        this.terminal.log(`  Team: ${config.teamName}`);
+        this.terminal.log(`  Space: ${config.spaceName}`);
+        this.terminal.log(`  Config: ${join(process.cwd(), BRV_DIR, PROJECT_CONFIG_FILE)}`);
+        this.terminal.log('\n Re-initializing will:');
+        this.terminal.log(`  - Remove the entire ${BRV_DIR}/ directory and all its contents`);
+        this.terminal.log('  - Allow you to select a new team/space');
+        this.terminal.log('  - Create a fresh configuration and Context Tree');
+        this.terminal.log('  - Regenerate rule instructions\n');
+        return this.terminal.confirm({
             default: false,
             message: 'Continue with re-initialization?',
         });
     }
-    createServices() {
-        const envConfig = getCurrentConfig();
-        const tokenStore = new KeychainTokenStore();
-        const trackingService = new MixpanelTrackingService(tokenStore);
-        const fileService = new FsFileService();
-        const templateLoader = new FsTemplateLoader(fileService);
-        const ruleTemplateService = new RuleTemplateService(templateLoader);
-        const legacyRuleDetector = new LegacyRuleDetector();
-        const contextTreeSnapshotService = new FileContextTreeSnapshotService();
-        return {
-            cogitPullService: new HttpCogitPullService({
-                apiBaseUrl: envConfig.cogitApiBaseUrl,
-            }),
-            contextTreeService: new FileContextTreeService(),
-            contextTreeSnapshotService,
-            contextTreeWriterService: new FileContextTreeWriterService({ snapshotService: contextTreeSnapshotService }),
-            fileService,
-            legacyRuleDetector,
-            projectConfigStore: new ProjectConfigStore(),
-            // ruleWriterService: new RuleWriterService(fileService, ruleTemplateService),
-            spaceService: new HttpSpaceService({
-                apiBaseUrl: envConfig.apiBaseUrl,
-            }),
-            teamService: new HttpTeamService({
-                apiBaseUrl: envConfig.apiBaseUrl,
-            }),
-            templateService: ruleTemplateService,
-            tokenStore,
-            trackingService,
-        };
-    }
     detectWorkspacesForAgent(agent) {
         const detector = new WorkspaceDetectorService();
         const result = detector.detectWorkspaces(agent);
@@ -121,42 +92,44 @@ export default class Init extends Command {
             cwd: result.cwd,
         };
     }
-    async ensureAuthenticated(tokenStore) {
-        const token = await tokenStore.load();
+    async ensureAuthenticated() {
+        const token = await this.tokenStore.load();
         if (token === undefined) {
-            this.error('Not authenticated. Please run "brv login" first.');
+            this.terminal.log('Not authenticated. Please run "/login" first.');
+            return undefined;
         }
         if (!token.isValid()) {
-            this.error('Authentication token expired. Please run "brv login" again.');
+            this.terminal.log('Authentication token expired. Please run "/login" again.');
+            return undefined;
         }
         return token;
     }
-    async fetchAndSelectSpace(spaceService, token, team) {
-        ux.action.start('\nFetching all spaces');
-        const { spaces } = await spaceService.getSpaces(token.accessToken, token.sessionKey, team.id, { fetchAll: true });
-        ux.action.stop();
+    async fetchAndSelectSpace(token, team) {
+        this.terminal.actionStart('\nFetching all spaces');
+        const { spaces } = await this.spaceService.getSpaces(token.accessToken, token.sessionKey, team.id, { fetchAll: true });
+        this.terminal.actionStop();
         if (spaces.length === 0) {
-            this.log(`No spaces found in team "${team.getDisplayName()}"`);
-            this.log(`Please visit ${getCurrentConfig().webAppUrl} to create your first space for ${team.getDisplayName()}.`);
+            this.terminal.log(`No spaces found in team "${team.getDisplayName()}"`);
+            this.terminal.log(`Please visit ${getCurrentConfig().webAppUrl} to create your first space for ${team.getDisplayName()}.`);
             return undefined;
         }
-        this.log();
+        this.terminal.log();
         return this.promptForSpaceSelection(spaces);
     }
-    async fetchAndSelectTeam(teamService, token) {
-        ux.action.start('Fetching all teams');
-        const { teams } = await teamService.getTeams(token.accessToken, token.sessionKey, { fetchAll: true });
-        ux.action.stop();
+    async fetchAndSelectTeam(token) {
+        this.terminal.actionStart('Fetching all teams');
+        const { teams } = await this.teamService.getTeams(token.accessToken, token.sessionKey, { fetchAll: true });
+        this.terminal.actionStop();
         if (teams.length === 0) {
-            this.log('No teams found.');
-            this.log(`Please visit ${getCurrentConfig().webAppUrl} to create your first team.`);
+            this.terminal.log('No teams found.');
+            this.terminal.log(`Please visit ${getCurrentConfig().webAppUrl} to create your first team.`);
             return undefined;
         }
-        this.log();
+        this.terminal.log();
         return this.promptForTeamSelection(teams);
     }
-    async generateRulesForAgent(selectedAgent, fileService, templateService, legacyRuleDetector) {
-        this.log(`Generating rules for: ${selectedAgent}`);
+    async generateRulesForAgent(selectedAgent) {
+        this.terminal.log(`Generating rules for: ${selectedAgent}`);
         // try {
         //   await ruleWriterService.writeRule(agent, false)
         //   this.log(`✅ Successfully generated rule file for ${agent}`)
@@ -175,24 +148,22 @@ export default class Init extends Command {
         // }
         const { filePath, writeMode } = AGENT_RULE_CONFIGS[selectedAgent];
         // STEP 1: Check if file exists
-        const fileExists = await fileService.exists(filePath);
+        const fileExists = await this.fileService.exists(filePath);
         if (!fileExists) {
             // Scenario A: File doesn't exist
             const shouldCreate = await this.promptForFileCreation(selectedAgent, filePath);
             if (!shouldCreate) {
-                this.log(`Skipped rule file creation for ${selectedAgent}`);
+                this.terminal.log(`Skipped rule file creation for ${selectedAgent}`);
                 return;
             }
             await this.createNewRuleFile({
                 agent: selectedAgent,
                 filePath,
-                fileService,
-                templateService,
             });
             return;
         }
         // STEP 2: File exists - read content
-        const content = await fileService.read(filePath);
+        const content = await this.fileService.read(filePath);
         // STEP 3: Check for LEGACY rules (priority: clean these up first)
         const hasFooterTag = content.includes(`${BRV_RULE_TAG} ${selectedAgent}`);
         const hasBoundaryMarkers = content.includes(BRV_RULE_MARKERS.START) && content.includes(BRV_RULE_MARKERS.END);
@@ -203,9 +174,6 @@ export default class Init extends Command {
                 agent: selectedAgent,
                 content,
                 filePath,
-                fileService,
-                legacyRuleDetector,
-                templateService,
             });
             return;
         }
@@ -214,15 +182,13 @@ export default class Init extends Command {
             // Scenario C: New rules exist - prompt for overwrite
             const shouldOverwrite = await this.promptForOverwriteConfirmation(selectedAgent);
             if (!shouldOverwrite) {
-                this.log(`Skipped rule file update for ${selectedAgent}`);
+                this.terminal.log(`Skipped rule file update for ${selectedAgent}`);
                 return;
             }
             await this.replaceExistingRules({
                 agent: selectedAgent,
                 content,
                 filePath,
-                fileService,
-                templateService,
                 writeMode,
             });
             return;
@@ -231,19 +197,19 @@ export default class Init extends Command {
         await this.appendRulesToFile({
             agent: selectedAgent,
             filePath,
-            fileService,
-            templateService,
             writeMode,
         });
     }
-    async getExistingConfig(projectConfigStore) {
-        const exists = await projectConfigStore.exists();
+    async getExistingConfig() {
+        const exists = await this.projectConfigStore.exists();
         if (!exists)
             return undefined;
         try {
-            const projectConfig = await projectConfigStore.read();
+            const projectConfig = await this.projectConfigStore.read();
             if (projectConfig === undefined) {
-                throw new Error('Configuration file exists but cannot be read. Please check .brv/config.json');
+                const corruptedConfigFileErr = 'Configuration file exists but cannot be read. Please check .brv/config.json';
+                this.trackingService.track('init', { message: corruptedConfigFileErr, status: 'error' });
+                throw new Error(corruptedConfigFileErr);
             }
             return projectConfig;
         }
@@ -266,13 +232,13 @@ export default class Init extends Command {
         }
     }
     async initializeMemoryContextDir(name, initFn) {
-        this.log(`\nInitializing ${name}...`);
+        this.terminal.log(`\nInitializing ${name}...`);
         try {
             const path = await initFn();
-            this.log(`✓ ${name} initialized in ${path}`);
+            this.terminal.log(`✓ ${name} initialized in ${path}`);
         }
         catch (error) {
-            this.warn(`${name} initialization skipped: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            this.terminal.warn(`${name} initialization skipped: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
     isLegacyProjectConfig(config) {
@@ -287,13 +253,13 @@ export default class Init extends Command {
         return normalizedPath === 'README.md';
     }
     async promptAceDeprecationRemoval() {
-        this.log('\n The ACE system is being deprecated.');
-        this.log(' ByteRover is migrating to the new Context Tree system for improved');
-        this.log(' memory organization and retrieval.');
-        this.log('');
-        this.log(' We detected an existing ACE folder at .brv/ace/');
-        this.log(' This folder and all its contents can be safely removed.\n');
-        return confirm({
+        this.terminal.log('\n The ACE system is being deprecated.');
+        this.terminal.log(' ByteRover is migrating to the new Context Tree system for improved');
+        this.terminal.log(' memory organization and retrieval.');
+        this.terminal.log('');
+        this.terminal.log(' We detected an existing ACE folder at .brv/ace/');
+        this.terminal.log(' This folder and all its contents can be safely removed.\n');
+        return this.terminal.confirm({
             default: true,
             message: 'Remove the ACE folder and its contents?',
         });
@@ -308,16 +274,15 @@ export default class Init extends Command {
             name: agent,
             value: agent,
         }));
-        const answer = await search({
+        return this.terminal.search({
             message: 'Which agent you are using (type to search):',
-            async source(input) {
+            source(input) {
                 if (!input)
                     return AGENTS;
                 return AGENTS.filter((agent) => agent.name.toLowerCase().includes(input.toLowerCase()) ||
                     agent.value.toLowerCase().includes(input.toLowerCase()));
             },
         });
-        return answer;
     }
     /**
      * Prompts the user to choose cleanup strategy for legacy rules.
@@ -325,7 +290,7 @@ export default class Init extends Command {
      * @returns The chosen cleanup strategy
      */
     async promptForCleanupStrategy() {
-        return select({
+        return this.terminal.select({
             choices: [
                 {
                     description: 'New rules will be added with boundary markers. You manually remove old sections at your convenience.',
@@ -349,7 +314,7 @@ export default class Init extends Command {
      * @returns True if the user wants to create the file, false otherwise
      */
     async promptForFileCreation(agent, filePath) {
-        return confirm({
+        return this.terminal.confirm({
             default: true,
             message: `Rule file '${filePath}' doesn't exist. Create it with ByteRover rules?`,
         });
@@ -359,13 +324,13 @@ export default class Init extends Command {
      * This method is protected to allow test overrides.
      */
     async promptForOverwriteConfirmation(agent) {
-        return confirm({
+        return this.terminal.confirm({
             default: true,
             message: `Rule file already exists for ${agent}. Overwrite?`,
         });
     }
     async promptForSpaceSelection(spaces) {
-        const selectedSpaceId = await select({
+        const selectedSpaceId = await this.terminal.select({
             choices: spaces.map((space) => ({
                 name: space.getDisplayName(),
                 value: space.id,
@@ -374,12 +339,13 @@ export default class Init extends Command {
         });
         const selectedSpace = spaces.find((space) => space.id === selectedSpaceId);
         if (!selectedSpace) {
-            this.error('Space selection failed');
+            this.terminal.log('Space selection failed');
+            return undefined;
         }
         return selectedSpace;
     }
     async promptForTeamSelection(teams) {
-        const selectedTeamId = await select({
+        const selectedTeamId = await this.terminal.select({
             choices: teams.map((team) => ({
                 name: team.name,
                 value: team.id,
@@ -388,7 +354,8 @@ export default class Init extends Command {
         });
         const selectedTeam = teams.find((team) => team.id === selectedTeamId);
         if (!selectedTeam) {
-            this.error('Team selection failed');
+            this.terminal.log('Team selection failed');
+            return undefined;
         }
         return selectedTeam;
     }
@@ -397,30 +364,29 @@ export default class Init extends Command {
         const acePath = join(dir, BRV_DIR, ACE_DIR);
         await rm(acePath, { force: true, recursive: true });
     }
-    async run() {
+    async run(options) {
         try {
-            const { flags } = await this.parse(Init);
-            const { cogitPullService, contextTreeService, contextTreeSnapshotService, contextTreeWriterService, fileService, legacyRuleDetector, projectConfigStore, 
-            // ruleWriterService,
-            spaceService, teamService, templateService, tokenStore, trackingService, } = this.createServices();
-            const authToken = await this.ensureAuthenticated(tokenStore);
-            const existingConfig = await this.getExistingConfig(projectConfigStore);
+            await this.trackingService.track('init', { status: 'started' });
+            const authToken = await this.ensureAuthenticated();
+            if (!authToken)
+                return;
+            const existingConfig = await this.getExistingConfig();
             if (existingConfig) {
-                const shouldCleanup = flags.force ? true : await this.confirmReInitialization(existingConfig);
+                const shouldCleanup = options.force ? true : await this.confirmReInitialization(existingConfig);
                 if (shouldCleanup) {
                     await this.cleanupBeforeReInitialization();
-                    this.log('\n');
+                    this.terminal.log('\n');
                 }
                 else {
-                    this.log('\nCancelled. Project configuration unchanged.');
+                    this.terminal.log('\nCancelled. Project configuration unchanged.');
                     return;
                 }
             }
-            this.log('Initializing ByteRover project...\n');
-            const selectedTeam = await this.fetchAndSelectTeam(teamService, authToken);
+            this.terminal.log('Initializing ByteRover project...\n');
+            const selectedTeam = await this.fetchAndSelectTeam(authToken);
             if (!selectedTeam)
                 return;
-            const selectedSpace = await this.fetchAndSelectSpace(spaceService, authToken, selectedTeam);
+            const selectedSpace = await this.fetchAndSelectSpace(authToken, selectedTeam);
             if (!selectedSpace)
                 return;
             // Handle ACE deprecation - check for existing ACE folder and offer removal
@@ -429,46 +395,47 @@ export default class Init extends Command {
                 const shouldRemoveAce = await this.promptAceDeprecationRemoval();
                 if (shouldRemoveAce) {
                     await this.removeAceDirectory();
-                    this.log('✓ ACE folder removed');
+                    this.terminal.log('✓ ACE folder removed');
                 }
             }
             // Sync from remote or initialize context tree with templates
             await this.syncFromRemoteOrInitialize({
-                cogitPullService,
-                contextTreeService,
-                contextTreeSnapshotService,
-                contextTreeWriterService,
                 projectConfig: { spaceId: selectedSpace.id, teamId: selectedTeam.id },
                 token: authToken,
             });
-            this.log();
+            this.terminal.log();
             const selectedAgent = await this.promptForAgentSelection();
-            this.log('Detecting workspaces...');
+            this.terminal.log('Detecting workspaces...');
             const { chatLogPath, cwd } = this.detectWorkspacesForAgent(selectedAgent);
-            this.log(`✓ Detected workspace: ${cwd}`);
+            this.terminal.log(`✓ Detected workspace: ${cwd}`);
             const config = BrvConfig.fromSpace({
                 chatLogPath,
                 cwd,
                 ide: selectedAgent,
                 space: selectedSpace,
             });
-            await projectConfigStore.write(config);
-            this.log(`\nGenerate rule instructions for coding agents to work with ByteRover correctly`);
-            this.log();
-            await this.generateRulesForAgent(selectedAgent, fileService, templateService, legacyRuleDetector);
-            await trackingService.track('rule:generate');
-            await trackingService.track('space:init');
+            await this.projectConfigStore.write(config);
+            this.terminal.log(`\nGenerate rule instructions for coding agents to work with ByteRover correctly`);
+            this.terminal.log();
+            await this.generateRulesForAgent(selectedAgent);
+            await this.trackingService.track('rule:generate');
+            await this.trackingService.track('space:init');
             this.logSuccess(selectedSpace);
+            await this.trackingService.track('init', { status: 'finished' });
         }
         catch (error) {
-            this.error(`Initialization failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            // Stop action if it's in progress
+            this.terminal.actionStop();
+            const initErr = `Initialization failed: ${error instanceof Error ? error.message : 'Unknown error'}`;
+            await this.trackingService.track('init', { message: initErr, status: 'error' });
+            this.terminal.error(initErr);
         }
     }
     async syncFromRemoteOrInitialize(params) {
         // Pull from remote - fail if network/API error
-        this.log('\nSyncing from ByteRover...');
+        this.terminal.log('\nSyncing from ByteRover...');
         try {
-            const coGitSnapshot = await params.cogitPullService.pull({
+            const coGitSnapshot = await this.cogitPullService.pull({
                 accessToken: params.token.accessToken,
                 branch: DEFAULT_BRANCH,
                 sessionKey: params.token.sessionKey,
@@ -481,67 +448,67 @@ export default class Init extends Command {
                 (coGitSnapshot.files.length === 1 && this.isReadmePlaceholder(coGitSnapshot.files[0].path));
             if (isEmptySpace) {
                 // Remote is empty - ignore placeholder, create templates with empty snapshot
-                await this.initializeMemoryContextDir('context tree', () => params.contextTreeService.initialize());
-                await params.contextTreeSnapshotService.initEmptySnapshot();
-                this.log('✓ Context tree initialized');
+                await this.initializeMemoryContextDir('context tree', () => this.contextTreeService.initialize());
+                await this.contextTreeSnapshotService.initEmptySnapshot();
+                this.terminal.log('✓ Context tree initialized');
             }
             else {
                 // Remote has real data - sync it to local
-                await params.contextTreeWriterService.sync({ files: [...coGitSnapshot.files] });
-                await params.contextTreeSnapshotService.saveSnapshot();
-                this.log(`✓ Synced ${coGitSnapshot.files.length} context files from remote`);
+                await this.contextTreeWriterService.sync({ files: [...coGitSnapshot.files] });
+                await this.contextTreeSnapshotService.saveSnapshot();
+                this.terminal.log(`✓ Synced ${coGitSnapshot.files.length} context files from remote`);
             }
         }
         catch (error) {
-            throw new Error(`Failed to sync from ByteRover: ${error instanceof Error ? error.message : 'Unknown error'}. Please try again.`);
+            const syncFailureErr = `Failed to sync from ByteRover: ${error instanceof Error ? error.message : 'Unknown error'}. Please try again.`;
+            await this.trackingService.track('init', { message: syncFailureErr, status: 'error' });
+            throw new Error(syncFailureErr);
         }
     }
     /**
      * Appends ByteRover rules to a file that has no ByteRover content.
      */
     async appendRulesToFile(params) {
-        const { agent, filePath, fileService, templateService, writeMode } = params;
-        const ruleContent = await templateService.generateRuleContent(agent);
+        const { agent, filePath, writeMode } = params;
+        const ruleContent = await this.templateService.generateRuleContent(agent);
         // For dedicated ByteRover files, overwrite; for shared instruction files, append
         const mode = writeMode === 'overwrite' ? 'overwrite' : 'append';
-        await fileService.write(ruleContent, filePath, mode);
-        this.log(`✅ Successfully added rule file for ${agent}`);
+        await this.fileService.write(ruleContent, filePath, mode);
+        this.terminal.log(`✅ Successfully added rule file for ${agent}`);
     }
     /**
      * Creates a new rule file with ByteRover rules.
      */
     async createNewRuleFile(params) {
-        const { agent, filePath, fileService, templateService } = params;
-        const ruleContent = await templateService.generateRuleContent(agent);
-        await fileService.write(ruleContent, filePath, 'overwrite');
-        this.log(`✅ Successfully created rule file for ${agent} at ${filePath}`);
+        const { agent, filePath } = params;
+        const ruleContent = await this.templateService.generateRuleContent(agent);
+        await this.fileService.write(ruleContent, filePath, 'overwrite');
+        this.terminal.log(`✅ Successfully created rule file for ${agent} at ${filePath}`);
     }
     async handleLegacyRulesCleanup(params) {
-        const { agent, content, filePath, fileService, legacyRuleDetector, templateService } = params;
-        const detectionResult = legacyRuleDetector.detectLegacyRules(content, agent);
+        const { agent, content, filePath } = params;
+        const detectionResult = this.legacyRuleDetector.detectLegacyRules(content, agent);
         const { reliableMatches, uncertainMatches } = detectionResult;
-        this.log(`\n⚠️  Detected ${reliableMatches.length + uncertainMatches.length} old ByteRover rule section(s) in ${filePath}:\n`);
+        this.terminal.log(`\n⚠️  Detected ${reliableMatches.length + uncertainMatches.length} old ByteRover rule section(s) in ${filePath}:\n`);
         if (reliableMatches.length > 0) {
-            this.log('Reliable matches:');
+            this.terminal.log('Reliable matches:');
             for (const [index, match] of reliableMatches.entries()) {
-                this.log(`  Section ${index + 1}: lines ${match.startLine}-${match.endLine}`);
+                this.terminal.log(`  Section ${index + 1}: lines ${match.startLine}-${match.endLine}`);
             }
-            this.log();
+            this.terminal.log();
         }
         if (uncertainMatches.length > 0) {
-            this.log('  ⚠️  Uncertain matches (cannot determine start):');
+            this.terminal.log('  ⚠️  Uncertain matches (cannot determine start):');
             for (const match of uncertainMatches) {
-                this.log(`  Footer found at line ${match.footerLine}`);
-                this.log(`  Reason: ${match.reason}`);
+                this.terminal.log(`  Footer found at line ${match.footerLine}`);
+                this.terminal.log(`  Reason: ${match.reason}`);
             }
-            this.log();
-            this.log('⚠️  Due to uncertain matches, only manual cleanup is available.\n');
+            this.terminal.log();
+            this.terminal.log('⚠️  Due to uncertain matches, only manual cleanup is available.\n');
             await this.performManualCleanup({
                 agent,
                 filePath,
-                fileService,
                 reliableMatches,
-                templateService,
                 uncertainMatches,
             });
             return;
@@ -551,69 +518,65 @@ export default class Init extends Command {
             ? this.performManualCleanup({
                 agent,
                 filePath,
-                fileService,
                 reliableMatches,
-                templateService,
                 uncertainMatches,
             })
             : this.performAutomaticCleanup({
                 agent,
                 filePath,
-                fileService,
                 reliableMatches,
-                templateService,
             }));
     }
     logSuccess(space) {
-        this.log(`\n✓ Project initialized successfully!`);
-        this.log(`✓ Connected to space: ${space.getDisplayName()}`);
-        this.log(`✓ Configuration saved to: ${BRV_DIR}/${PROJECT_CONFIG_FILE}`);
-        this.log("NOTE: It's recommended to add .brv/ to your .gitignore file since ByteRover already takes care of memory/context versioning for you.");
+        this.terminal.log(`\n✓ Project initialized successfully!`);
+        this.terminal.log(`✓ Connected to space: ${space.getDisplayName()}`);
+        this.terminal.log(`✓ Configuration saved to: ${BRV_DIR}/${PROJECT_CONFIG_FILE}`);
+        this.terminal.log("NOTE: It's recommended to add .brv/ to your .gitignore file since ByteRover already takes care of memory/context versioning for you.");
     }
     async performAutomaticCleanup(params) {
-        const { agent, filePath, fileService, reliableMatches, templateService } = params;
-        const backupPath = await fileService.createBackup(filePath);
-        this.log(`📦 Backup created: ${backupPath}`);
-        let content = await fileService.read(filePath);
+        const { agent, filePath, reliableMatches } = params;
+        const backupPath = await this.fileService.createBackup(filePath);
+        this.terminal.log(`📦 Backup created: ${backupPath}`);
+        let content = await this.fileService.read(filePath);
         // Remove all reliable matches (in reverse order to preserve line numbers)
         const sortedMatches = [...reliableMatches].sort((a, b) => b.startLine - a.startLine);
         for (const match of sortedMatches) {
             content = content.replace(match.content, '');
         }
         // Write cleaned content
-        await fileService.write(content, filePath, 'overwrite');
+        await this.fileService.write(content, filePath, 'overwrite');
         // Append new rules
-        const ruleContent = await templateService.generateRuleContent(agent);
-        await fileService.write(ruleContent, filePath, 'append');
-        this.log(`✅ Removed ${reliableMatches.length} old ByteRover section(s)`);
-        this.log(`✅ Added new rules with boundary markers`);
-        this.log(`\nYou can safely delete the backup file once verified.`);
+        const ruleContent = await this.templateService.generateRuleContent(agent);
+        await this.fileService.write(ruleContent, filePath, 'append');
+        this.terminal.log(`✅ Removed ${reliableMatches.length} old ByteRover section(s)`);
+        this.terminal.log(`✅ Added new rules with boundary markers`);
+        this.terminal.log(`\nYou can safely delete the backup file once verified.`);
     }
     async performManualCleanup(params) {
-        const { agent, filePath, fileService, reliableMatches, templateService, uncertainMatches } = params;
-        const ruleContent = await templateService.generateRuleContent(agent);
-        await fileService.write(ruleContent, filePath, 'append');
-        this.log(`✅ New ByteRover rules added with boundary markers\n`);
-        this.log('Please manually remove old sections:');
+        const { agent, filePath, reliableMatches, uncertainMatches } = params;
+        const ruleContent = await this.templateService.generateRuleContent(agent);
+        await this.fileService.write(ruleContent, filePath, 'append');
+        this.terminal.log(`✅ New ByteRover rules added with boundary markers\n`);
+        this.terminal.log('Please manually remove old sections:');
         for (const [index, match] of reliableMatches.entries()) {
-            this.log(`  - Section ${index + 1}: lines ${match.startLine}-${match.endLine} in ${filePath}`);
+            this.terminal.log(`  - Section ${index + 1}: lines ${match.startLine}-${match.endLine} in ${filePath}`);
         }
         for (const match of uncertainMatches) {
-            this.log(`  - Section ending at line ${match.footerLine} in ${filePath}`);
+            this.terminal.log(`  - Section ending at line ${match.footerLine} in ${filePath}`);
         }
-        this.log('\nKeep only the section between:');
-        this.log('  <!-- BEGIN BYTEROVER RULES -->');
-        this.log('  <!-- END BYTEROVER RULES -->');
+        this.terminal.log('\nKeep only the section between:');
+        this.terminal.log('  <!-- BEGIN BYTEROVER RULES -->');
+        this.terminal.log('  <!-- END BYTEROVER RULES -->');
     }
     /**
      * Replaces existing ByteRover rules (with boundary markers) with new rules.
      */
     async replaceExistingRules(params) {
-        const { agent, content, filePath, fileService, templateService, writeMode } = params;
-        const ruleContent = await templateService.generateRuleContent(agent);
+        const { agent, content, filePath, writeMode } = params;
+        const ruleContent = await this.templateService.generateRuleContent(agent);
         if (writeMode === 'overwrite') {
             // For dedicated ByteRover files, just overwrite the entire file
-            await fileService.write(ruleContent, filePath, 'overwrite');
+            await this.fileService.write(ruleContent, filePath, 'overwrite');
         }
         else {
             // For shared instruction files, replace the section between markers
@@ -622,13 +585,14 @@ export default class Init extends Command {
             const startIndex = content.indexOf(startMarker);
             const endIndex = content.indexOf(endMarker, startIndex);
             if (startIndex === -1 || endIndex === -1) {
-                this.error('Could not find boundary markers in the file');
+                this.terminal.log('Could not find boundary markers in the file');
+                return;
             }
             const before = content.slice(0, startIndex);
             const after = content.slice(endIndex + endMarker.length);
             const newContent = before + ruleContent + after;
-            await fileService.write(newContent, filePath, 'overwrite');
+            await this.fileService.write(newContent, filePath, 'overwrite');
         }
-        this.log(`✅ Successfully updated rule file for ${agent}`);
+        this.terminal.log(`✅ Successfully updated rule file for ${agent}`);
     }
 }