byterover-cli 0.3.5 → 0.4.0

package/dist/infra/terminal/oclif-terminal.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+import type { ConfirmOptions, FileSelectorItem, FileSelectorOptions, InputOptions, ITerminal, SearchOptions, SelectOptions } from '../../core/interfaces/i-terminal.js';
+/**
+ * Terminal implementation that wraps oclif Command methods and @inquirer/prompts.
+ */
+export declare class OclifTerminal implements ITerminal {
+    private readonly command;
+    constructor(command: Command);
+    actionStart(message: string): void;
+    actionStop(message?: string): void;
+    confirm({ default: defaultValue, message }: ConfirmOptions): Promise<boolean>;
+    error(message: string): void;
+    fileSelector(options: FileSelectorOptions): Promise<FileSelectorItem | null>;
+    input({ message, validate }: InputOptions): Promise<string>;
+    log(message?: string): void;
+    search<T>({ message, source }: SearchOptions<T>): Promise<T>;
+    select<T>({ choices, message }: SelectOptions<T>): Promise<T>;
+    warn(message: string): void;
+}

package/dist/infra/terminal/oclif-terminal.js

@@ -0,0 +1,60 @@
+import { confirm, input, search, select } from '@inquirer/prompts';
+import { ux } from '@oclif/core';
+import { fileSelector, ItemType } from 'inquirer-file-selector';
+/**
+ * Terminal implementation that wraps oclif Command methods and @inquirer/prompts.
+ */
+export class OclifTerminal {
+    command;
+    constructor(command) {
+        this.command = command;
+    }
+    actionStart(message) {
+        ux.action.start(message);
+    }
+    actionStop(message) {
+        ux.action.stop(message);
+    }
+    confirm({ default: defaultValue = true, message }) {
+        return confirm({ default: defaultValue, message });
+    }
+    error(message) {
+        this.command.error(message);
+    }
+    async fileSelector(options) {
+        const baseConfig = {
+            basePath: options.basePath,
+            filter: options.filter,
+            message: options.message,
+            pageSize: options.pageSize,
+            theme: options.theme,
+            type: options.type === 'directory' ? ItemType.Directory : ItemType.File,
+        };
+        // Use separate calls to help TypeScript infer the correct overload
+        const result = options.allowCancel
+            ? await fileSelector({ ...baseConfig, allowCancel: true })
+            : await fileSelector({ ...baseConfig, allowCancel: false });
+        if (!result)
+            return null;
+        return {
+            isDirectory: result.isDirectory,
+            name: result.name,
+            path: result.path,
+        };
+    }
+    input({ message, validate }) {
+        return input({ message, validate });
+    }
+    log(message) {
+        this.command.log(message);
+    }
+    search({ message, source }) {
+        return search({ message, source });
+    }
+    select({ choices, message }) {
+        return select({ choices, message });
+    }
+    warn(message) {
+        this.command.warn(message);
+    }
+}

package/dist/infra/terminal/repl-terminal.d.ts

@@ -0,0 +1,31 @@
+import type { ConfirmOptions, FileSelectorItem, FileSelectorOptions, InputOptions, ITerminal, SearchOptions, SelectOptions } from '../../core/interfaces/i-terminal.js';
+import type { PromptRequest, StreamingMessage } from '../../tui/types.js';
+/**
+ * Callbacks for ReplTerminal operations.
+ * These bridge the terminal to the TUI streaming system.
+ */
+export interface ReplTerminalCallbacks {
+    /** Callback for streaming output messages */
+    onMessage: (msg: StreamingMessage) => void;
+    /** Callback for interactive prompts */
+    onPrompt: (prompt: PromptRequest) => void;
+}
+/**
+ * REPL-compatible ITerminal implementation.
+ * Uses callbacks to integrate with TUI streaming and prompt system.
+ */
+export declare class ReplTerminal implements ITerminal {
+    private readonly callbacks;
+    private currentActionId;
+    constructor(callbacks: ReplTerminalCallbacks);
+    actionStart(message: string): void;
+    actionStop(message?: string): void;
+    confirm(options: ConfirmOptions): Promise<boolean>;
+    error(message: string): void;
+    fileSelector(options: FileSelectorOptions): Promise<FileSelectorItem | null>;
+    input(options: InputOptions): Promise<string>;
+    log(message?: string): void;
+    search<T>(options: SearchOptions<T>): Promise<T>;
+    select<T>(options: SelectOptions<T>): Promise<T>;
+    warn(message: string): void;
+}

package/dist/infra/terminal/repl-terminal.js

@@ -0,0 +1,116 @@
+import { randomUUID } from 'node:crypto';
+/**
+ * Generate a unique message ID
+ */
+function generateId() {
+    return randomUUID();
+}
+/**
+ * REPL-compatible ITerminal implementation.
+ * Uses callbacks to integrate with TUI streaming and prompt system.
+ */
+export class ReplTerminal {
+    callbacks;
+    currentActionId = null;
+    constructor(callbacks) {
+        this.callbacks = callbacks;
+    }
+    actionStart(message) {
+        // Generate a unique action ID to link start/stop
+        this.currentActionId = generateId();
+        this.callbacks.onMessage({
+            actionId: this.currentActionId,
+            content: message,
+            id: generateId(),
+            type: 'action_start',
+        });
+    }
+    actionStop(message) {
+        // Stop action if it's in progress
+        if (!this.currentActionId) {
+            return;
+        }
+        this.callbacks.onMessage({
+            actionId: this.currentActionId,
+            content: message ?? '',
+            id: generateId(),
+            type: 'action_stop',
+        });
+        this.currentActionId = null;
+    }
+    confirm(options) {
+        return new Promise((resolve) => {
+            this.callbacks.onPrompt({
+                default: options.default,
+                message: options.message,
+                onResponse: resolve,
+                type: 'confirm',
+            });
+        });
+    }
+    error(message) {
+        this.callbacks.onMessage({
+            content: message,
+            id: generateId(),
+            type: 'error',
+        });
+    }
+    fileSelector(options) {
+        return new Promise((resolve) => {
+            this.callbacks.onPrompt({
+                allowCancel: options.allowCancel,
+                basePath: options.basePath,
+                filter: options.filter,
+                message: options.message,
+                mode: options.type,
+                onResponse: resolve,
+                pageSize: options.pageSize,
+                type: 'file_selector',
+            });
+        });
+    }
+    input(options) {
+        return new Promise((resolve) => {
+            this.callbacks.onPrompt({
+                message: options.message,
+                onResponse: resolve,
+                type: 'input',
+                validate: options.validate,
+            });
+        });
+    }
+    log(message) {
+        this.callbacks.onMessage({
+            content: message ?? '',
+            id: generateId(),
+            type: 'output',
+        });
+    }
+    search(options) {
+        return new Promise((resolve) => {
+            this.callbacks.onPrompt({
+                message: options.message,
+                onResponse: resolve,
+                source: options.source,
+                type: 'search',
+            });
+        });
+    }
+    select(options) {
+        return new Promise((resolve) => {
+            this.callbacks.onPrompt({
+                choices: options.choices,
+                message: options.message,
+                onResponse: resolve,
+                type: 'select',
+            });
+        });
+    }
+    warn(message) {
+        this.callbacks.onMessage({
+            content: message,
+            id: generateId(),
+            type: 'warning',
+        });
+    }
+}

package/dist/infra/tracking/mixpanel-tracking-service.d.ts

@@ -1,14 +1,24 @@
 import { Mixpanel } from 'mixpanel';
 import { EventName, PropertyDict } from '../../core/domain/entities/event.js';
+import { IGlobalConfigStore } from '../../core/interfaces/i-global-config-store.js';
 import { ITokenStore } from '../../core/interfaces/i-token-store.js';
 import { ITrackingService } from '../../core/interfaces/i-tracking-service.js';
+/**
+ * Parameters for creating a MixpanelTrackingService instance.
+ */
+export interface MixpanelTrackingServiceParams {
+    readonly globalConfigStore: IGlobalConfigStore;
+    readonly mixpanel?: Mixpanel;
+    readonly tokenStore: ITokenStore;
+}
 /**
  * Tracking service implementation using the Mixpanel library.
  */
 export declare class MixpanelTrackingService implements ITrackingService {
+    private readonly globalConfigStore;
     private readonly mp;
     private readonly tokenStore;
-    constructor(tokenStore: ITokenStore, mp?: Mixpanel);
+    constructor(params: MixpanelTrackingServiceParams);
     track(eventName: EventName, properties?: PropertyDict): Promise<void>;
     private getIdentificationProperties;
 }

package/dist/infra/tracking/mixpanel-tracking-service.js

@@ -4,19 +4,21 @@ import { getCurrentConfig } from '../../config/environment.js';
  * Tracking service implementation using the Mixpanel library.
  */
 export class MixpanelTrackingService {
+    globalConfigStore;
     mp;
     tokenStore;
-    constructor(tokenStore, mp) {
-        this.tokenStore = tokenStore;
-        if (mp) {
-            // Injected dependencies for testing
-            this.mp = mp;
-        }
-        else {
+    constructor(params) {
+        this.tokenStore = params.tokenStore;
+        this.globalConfigStore = params.globalConfigStore;
+        if (params.mixpanel === undefined) {
             // Initialize with real implementations for production
             const envConfig = getCurrentConfig();
             this.mp = mixpanel.init(envConfig.mixpanelToken);
         }
+        else {
+            // Injected dependencies for testing
+            this.mp = params.mixpanel;
+        }
     }
     async track(eventName, properties) {
         try {
@@ -32,13 +34,16 @@ export class MixpanelTrackingService {
         }
     }
     async getIdentificationProperties() {
-        // 2. Load and validate authentication token
+        // Always include $device_id for anonymous/pre-auth tracking
+        const deviceId = await this.globalConfigStore.getOrCreateDeviceId();
+        const props = {
+            $device_id: deviceId, // eslint-disable-line camelcase
+        };
+        // Add $user_id if authenticated (enables Mixpanel identity merging)
         const token = await this.tokenStore.load();
-        if (token) {
-            return {
-                $user_id: token.userId, // eslint-disable-line camelcase
-            };
+        if (token !== undefined) {
+            props.$user_id = token.userId; // eslint-disable-line camelcase
         }
-        return {};
+        return props;
     }
 }

package/dist/infra/usecase/clear-use-case.d.ts

@@ -0,0 +1,20 @@
+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 { ITerminal } from '../../core/interfaces/i-terminal.js';
+import type { IClearUseCase } from '../../core/interfaces/usecase/i-clear-use-case.js';
+export interface ClearUseCaseOptions {
+    contextTreeService: IContextTreeService;
+    contextTreeSnapshotService: IContextTreeSnapshotService;
+    terminal: ITerminal;
+}
+export declare class ClearUseCase implements IClearUseCase {
+    private readonly contextTreeService;
+    private readonly contextTreeSnapshotService;
+    private readonly terminal;
+    constructor(options: ClearUseCaseOptions);
+    protected confirmClear(): Promise<boolean>;
+    run(options: {
+        directory?: string;
+        skipConfirmation: boolean;
+    }): Promise<void>;
+}

package/dist/infra/usecase/clear-use-case.js

@@ -0,0 +1,58 @@
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { BRV_DIR, CONTEXT_TREE_DIR } from '../../constants.js';
+export class ClearUseCase {
+    contextTreeService;
+    contextTreeSnapshotService;
+    terminal;
+    constructor(options) {
+        this.contextTreeService = options.contextTreeService;
+        this.contextTreeSnapshotService = options.contextTreeSnapshotService;
+        this.terminal = options.terminal;
+    }
+    // Protected method for testability - can be overridden in tests
+    async confirmClear() {
+        return this.terminal.confirm({
+            default: false,
+            message: 'Are you sure you want to reset the context tree? This will remove all existing context and restore default domains.',
+        });
+    }
+    async run(options) {
+        try {
+            // Check if context tree exists
+            const exists = await this.contextTreeService.exists(options.directory);
+            if (!exists) {
+                this.terminal.log('No context tree found. Nothing to clear.');
+                return;
+            }
+            // Confirmation prompt (unless skipConfirmation is true)
+            if (!options.skipConfirmation) {
+                const confirmed = await this.confirmClear();
+                if (!confirmed) {
+                    this.terminal.log('Cancelled. Context tree was not reset.');
+                    return;
+                }
+            }
+            // Remove existing context tree directory
+            const baseDir = options.directory ?? process.cwd();
+            const contextTreeDir = join(baseDir, BRV_DIR, CONTEXT_TREE_DIR);
+            await rm(contextTreeDir, { force: true, recursive: true });
+            // Re-initialize context tree with default domains
+            await this.contextTreeService.initialize(options.directory);
+            // Re-initialize empty snapshot
+            await this.contextTreeSnapshotService.initEmptySnapshot(options.directory);
+            this.terminal.log('✓ Context tree reset successfully.');
+            this.terminal.log('  6 default domains restored: code_style, design, structure, compliance, testing, bug_fixes');
+        }
+        catch (error) {
+            // Handle user cancelling the prompt (Ctrl+C or closing stdin)
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes('User force closed') || errorMessage.includes('force closed')) {
+                this.terminal.log('Cancelled. Context tree was not reset.');
+                return;
+            }
+            // For other errors, log error message
+            this.terminal.error(error instanceof Error ? error.message : 'Failed to reset context tree');
+        }
+    }
+}

package/dist/infra/usecase/curate-use-case.d.ts

@@ -0,0 +1,66 @@
+import type { IProjectConfigStore } from '../../core/interfaces/i-project-config-store.js';
+import type { ITerminal } from '../../core/interfaces/i-terminal.js';
+import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
+import type { ITrackingService } from '../../core/interfaces/i-tracking-service.js';
+import type { CurateUseCaseRunOptions, ICurateUseCase } from '../../core/interfaces/usecase/i-curate-use-case.js';
+export interface CurateUseCaseOptions {
+    projectConfigStore: IProjectConfigStore;
+    terminal: ITerminal;
+    tokenStore: ITokenStore;
+    trackingService: ITrackingService;
+}
+export declare class CurateUseCase implements ICurateUseCase {
+    private readonly projectConfigStore;
+    private readonly terminal;
+    private readonly tokenStore;
+    private readonly trackingService;
+    constructor(options: CurateUseCaseOptions);
+    /**
+     * Create topic folder with context.md file
+     * @param targetPath - The parent path where the topic folder will be created
+     * @param topicName - The name of the topic folder to create
+     * @returns The path to the created context.md file
+     */
+    protected createTopicWithContextFile(targetPath: string, topicName: string): string;
+    /**
+     * Generate a unique session ID for the autonomous agent.
+     * Uses crypto.randomUUID() for guaranteed uniqueness (122 bits of entropy).
+     */
+    protected generateSessionId(): string;
+    /**
+     * Navigate through the context tree using file selector
+     * Returns the selected path relative to context-tree root
+     */
+    protected navigateContextTree(): Promise<null | string>;
+    /**
+     * Open a file in the default editor
+     * @param filePath - The path to the file to open
+     */
+    protected openFile(filePath: string): Promise<void>;
+    /**
+     * Prompt user to enter topic name with validation
+     * @param targetPath - The path where the topic folder will be created
+     * @returns The topic name or null if cancelled
+     */
+    protected promptForTopicName(targetPath: string): Promise<null | string>;
+    run(options: CurateUseCaseRunOptions): Promise<void>;
+    /**
+     * Handle workspace not initialized error
+     */
+    private handleWorkspaceError;
+    /**
+     * Process file paths from --files flag
+     * @param filePaths - Array of file paths (relative or absolute)
+     * @returns Formatted instructions for the agent to read the specified files, or undefined if validation fails
+     */
+    private processFileReferences;
+    /**
+     * Run in autonomous mode - push to queue for background processing
+     */
+    private runAutonomous;
+    /**
+     * Run in interactive mode with manual prompts
+     */
+    private runInteractive;
+    private validateTopicName;
+}