byterover-cli 2.5.2 → 2.6.0

package/dist/server/infra/memory/memory-to-playbook-mapper.js

@@ -1,51 +0,0 @@
-import { Bullet } from '../../core/domain/entities/bullet.js';
-import { Playbook } from '../../core/domain/entities/playbook.js';
-/**
- * Transforms a Memory entity into a Bullet entity for playbook storage.
- *
- * Mapping:
- * - memory.bulletId -> bullet.id
- * - memory.section -> bullet.section
- * - memory.content -> bullet.content
- * - memory.tags -> bullet.metadata.tags
- * - memory.nodeKeys -> bullet.metadata.relatedFiles
- * - memory.timestamp -> bullet.metadata.timestamp
- * - memory.id -> bullet.memoryId
- *
- * @param memory The Memory entity to transform
- * @returns A Bullet entity
- */
-export const transformMemoryToBullet = (memory) => {
-    const metadata = {
-        relatedFiles: [...memory.nodeKeys],
-        tags: [...memory.tags],
-        timestamp: memory.timestamp,
-    };
-    return new Bullet(memory.bulletId, memory.section, memory.content, metadata, memory.id);
-};
-/**
- * Transforms a RetrieveResult into a Playbook.
- *
- * This function:
- * 1. Combines both memories and relatedMemories from the result
- * 2. Transforms each Memory into a Bullet
- * 3. Organizes bullets by section
- * 4. Creates a new Playbook with nextId set to 1 (reset value)
- *
- * @param result The RetrieveResult containing memories from Memora service
- * @returns A Playbook containing all retrieved memories as bullets
- */
-export const transformRetrieveResultToPlaybook = (result) => {
-    const bulletsMap = new Map();
-    const sectionsMap = new Map();
-    const allMemories = [...result.memories, ...result.relatedMemories];
-    for (const memory of allMemories) {
-        const bullet = transformMemoryToBullet(memory);
-        bulletsMap.set(bullet.id, bullet);
-        if (!sectionsMap.has(bullet.section)) {
-            sectionsMap.set(bullet.section, []);
-        }
-        sectionsMap.get(bullet.section).push(bullet.id);
-    }
-    return new Playbook(bulletsMap, sectionsMap, bulletsMap.size + 1);
-};

package/dist/server/infra/storage/file-onboarding-preference-store.d.ts

@@ -1,10 +0,0 @@
-import type { IOnboardingPreferenceStore } from '../../core/interfaces/storage/i-onboarding-preference-store.js';
-/**
- * Onboarding preference store implementation using a lock file.
- * Stores last dismissed timestamp in XDG data directory.
- */
-export declare class FileOnboardingPreferenceStore implements IOnboardingPreferenceStore {
-    clear(): Promise<void>;
-    getLastDismissedAt(): Promise<number | undefined>;
-    setLastDismissedAt(timestamp: number): Promise<void>;
-}

package/dist/server/infra/storage/file-onboarding-preference-store.js

@@ -1,45 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { getGlobalDataDir } from '../../utils/global-data-path.js';
-const ONBOARDING_LOCK_FILE = join(getGlobalDataDir(), '.onboarding-dismissed');
-/**
- * Onboarding preference store implementation using a lock file.
- * Stores last dismissed timestamp in XDG data directory.
- */
-export class FileOnboardingPreferenceStore {
-    async clear() {
-        try {
-            if (existsSync(ONBOARDING_LOCK_FILE)) {
-                rmSync(ONBOARDING_LOCK_FILE);
-            }
-        }
-        catch {
-            // Ignore errors
-        }
-    }
-    async getLastDismissedAt() {
-        try {
-            if (!existsSync(ONBOARDING_LOCK_FILE)) {
-                return undefined;
-            }
-            const content = readFileSync(ONBOARDING_LOCK_FILE, 'utf8').trim();
-            const timestamp = Number.parseInt(content, 10);
-            return Number.isNaN(timestamp) ? undefined : timestamp;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    async setLastDismissedAt(timestamp) {
-        try {
-            const parentDir = dirname(ONBOARDING_LOCK_FILE);
-            if (!existsSync(parentDir)) {
-                mkdirSync(parentDir, { recursive: true });
-            }
-            writeFileSync(ONBOARDING_LOCK_FILE, String(timestamp), 'utf8');
-        }
-        catch {
-            // Silently ignore errors - onboarding preference is non-critical
-        }
-    }
-}

package/dist/server/infra/terminal/headless-terminal.d.ts

@@ -1,91 +0,0 @@
-import type { ConfirmOptions, FileSelectorItem, FileSelectorOptions, InputOptions, ITerminal, SearchOptions, SelectOptions } from '../../core/interfaces/services/i-terminal.js';
-/**
- * Output format for headless terminal.
- * - 'text': Human-readable text output
- * - 'json': NDJSON (newline-delimited JSON) for machine parsing
- */
-export type HeadlessOutputFormat = 'json' | 'text';
-/**
- * JSON message types for structured output.
- */
-export type HeadlessMessageType = 'action_start' | 'action_stop' | 'error' | 'log' | 'result' | 'warning';
-/**
- * Structured JSON output message.
- */
-export interface HeadlessJsonMessage {
-    actionId?: string;
-    id: string;
-    message: string;
-    timestamp: string;
-    type: HeadlessMessageType;
-}
-/**
- * Options for creating a HeadlessTerminal.
- */
-export interface HeadlessTerminalOptions {
-    /**
-     * Stream for errors (defaults to process.stderr).
-     */
-    errorStream?: NodeJS.WritableStream;
-    /**
-     * If true, throw HeadlessPromptError when a prompt cannot be answered.
-     * If false, use sensible defaults (first choice, false for confirm, etc.)
-     * @default true
-     */
-    failOnPrompt?: boolean;
-    /**
-     * Output format: 'text' for human readable, 'json' for machine parsing.
-     * @default 'text'
-     */
-    outputFormat?: HeadlessOutputFormat;
-    /**
-     * Stream for output (defaults to process.stdout).
-     */
-    outputStream?: NodeJS.WritableStream;
-    /**
-     * Default values for prompts, keyed by prompt message or prompt type.
-     * Used to answer prompts automatically in headless mode.
-     */
-    promptDefaults?: Record<string, unknown>;
-}
-/**
- * Terminal implementation for headless/non-interactive mode.
- * Outputs to stdout/stderr and handles prompts via defaults or fails gracefully.
- */
-export declare class HeadlessTerminal implements ITerminal {
-    private currentActionId;
-    private readonly errorOutput;
-    private readonly failOnPrompt;
-    private readonly output;
-    private readonly outputFormat;
-    private readonly promptDefaults;
-    constructor(options?: HeadlessTerminalOptions);
-    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;
-    /**
-     * Write final response with success/error status.
-     */
-    writeFinalResponse(response: {
-        command: string;
-        data?: unknown;
-        error?: {
-            code: string;
-            message: string;
-        };
-        success: boolean;
-    }): void;
-    /**
-     * Write final result in JSON format (convenience method for commands).
-     */
-    writeResult(data: Record<string, unknown>): void;
-    private getDefault;
-    private writeJson;
-}

package/dist/server/infra/terminal/headless-terminal.js

@@ -1,211 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { HeadlessPromptError } from '../../core/domain/errors/headless-prompt-error.js';
-/**
- * Terminal implementation for headless/non-interactive mode.
- * Outputs to stdout/stderr and handles prompts via defaults or fails gracefully.
- */
-export class HeadlessTerminal {
-    currentActionId = null;
-    errorOutput;
-    failOnPrompt;
-    output;
-    outputFormat;
-    promptDefaults;
-    constructor(options = {}) {
-        this.outputFormat = options.outputFormat ?? 'text';
-        this.promptDefaults = options.promptDefaults ?? {};
-        this.failOnPrompt = options.failOnPrompt ?? true;
-        this.output = options.outputStream ?? process.stdout;
-        this.errorOutput = options.errorStream ?? process.stderr;
-    }
-    // ==================== Output Methods ====================
-    actionStart(message) {
-        this.currentActionId = randomUUID();
-        if (this.outputFormat === 'json') {
-            this.writeJson({
-                actionId: this.currentActionId,
-                id: randomUUID(),
-                message,
-                timestamp: new Date().toISOString(),
-                type: 'action_start',
-            });
-        }
-        // In text mode, suppress action start for cleaner output
-    }
-    actionStop(message) {
-        if (this.outputFormat === 'json' && this.currentActionId) {
-            this.writeJson({
-                actionId: this.currentActionId,
-                id: randomUUID(),
-                message: message ?? '',
-                timestamp: new Date().toISOString(),
-                type: 'action_stop',
-            });
-        }
-        this.currentActionId = null;
-    }
-    async confirm(options) {
-        // Check for explicit default in promptDefaults
-        const defaultValue = this.getDefault('confirm', options.message);
-        if (defaultValue !== undefined) {
-            return Boolean(defaultValue);
-        }
-        // Use options.default if provided
-        if (options.default !== undefined) {
-            return options.default;
-        }
-        // Fail or return false
-        if (this.failOnPrompt) {
-            throw new HeadlessPromptError('confirm', options.message);
-        }
-        return false;
-    }
-    error(message) {
-        if (this.outputFormat === 'json') {
-            this.writeJson({
-                id: randomUUID(),
-                message,
-                timestamp: new Date().toISOString(),
-                type: 'error',
-            });
-        }
-        else {
-            this.errorOutput.write(`Error: ${message}\n`);
-        }
-    }
-    async fileSelector(options) {
-        // Check for explicit default in promptDefaults
-        const defaultValue = this.getDefault('file_selector', options.message);
-        if (defaultValue !== undefined && typeof defaultValue === 'string') {
-            return {
-                isDirectory: options.type === 'directory',
-                name: defaultValue.split('/').pop() ?? defaultValue,
-                path: defaultValue,
-            };
-        }
-        // Allow cancel if specified
-        if (options.allowCancel) {
-            return null;
-        }
-        // Fail
-        if (this.failOnPrompt) {
-            throw new HeadlessPromptError('file_selector', options.message);
-        }
-        return null;
-    }
-    // ==================== Input Methods ====================
-    async input(options) {
-        // Check for explicit default in promptDefaults
-        const defaultValue = this.getDefault('input', options.message);
-        if (defaultValue !== undefined) {
-            const value = String(defaultValue);
-            // Validate if validator is provided
-            if (options.validate) {
-                const validationResult = options.validate(value);
-                if (validationResult !== true) {
-                    const errorMsg = typeof validationResult === 'string' ? validationResult : 'Validation failed';
-                    throw new HeadlessPromptError('input', `${options.message} (validation error: ${errorMsg})`);
-                }
-            }
-            return value;
-        }
-        // Fail
-        if (this.failOnPrompt) {
-            throw new HeadlessPromptError('input', options.message);
-        }
-        return '';
-    }
-    log(message) {
-        if (this.outputFormat === 'json') {
-            this.writeJson({
-                id: randomUUID(),
-                message: message ?? '',
-                timestamp: new Date().toISOString(),
-                type: 'log',
-            });
-        }
-        else {
-            this.output.write((message ?? '') + '\n');
-        }
-    }
-    async search(options) {
-        // Search prompts require user interaction - always fail in headless mode
-        // unless a default is explicitly provided
-        const defaultValue = this.getDefault('search', options.message);
-        if (defaultValue !== undefined) {
-            return defaultValue;
-        }
-        throw new HeadlessPromptError('search', options.message);
-    }
-    async select(options) {
-        // Check for explicit default in promptDefaults (by value or name)
-        const defaultValue = this.getDefault('select', options.message);
-        if (defaultValue !== undefined) {
-            const choice = options.choices.find((c) => c.value === defaultValue || c.name === defaultValue);
-            if (choice) {
-                return choice.value;
-            }
-        }
-        // Fail or return first choice
-        if (this.failOnPrompt) {
-            throw new HeadlessPromptError('select', options.message, options.choices.map((c) => c.name));
-        }
-        // Return first choice as fallback
-        if (options.choices.length > 0) {
-            return options.choices[0].value;
-        }
-        throw new HeadlessPromptError('select', options.message, []);
-    }
-    warn(message) {
-        if (this.outputFormat === 'json') {
-            this.writeJson({
-                id: randomUUID(),
-                message,
-                timestamp: new Date().toISOString(),
-                type: 'warning',
-            });
-        }
-        else {
-            this.errorOutput.write(`Warning: ${message}\n`);
-        }
-    }
-    // ==================== Helper Methods ====================
-    /**
-     * Write final response with success/error status.
-     */
-    writeFinalResponse(response) {
-        if (this.outputFormat === 'json') {
-            this.output.write(JSON.stringify({
-                ...response,
-                timestamp: new Date().toISOString(),
-            }) + '\n');
-        }
-    }
-    /**
-     * Write final result in JSON format (convenience method for commands).
-     */
-    writeResult(data) {
-        if (this.outputFormat === 'json') {
-            this.writeJson({
-                id: randomUUID(),
-                message: JSON.stringify(data),
-                timestamp: new Date().toISOString(),
-                type: 'result',
-            });
-        }
-    }
-    getDefault(promptType, promptMessage) {
-        // First check by exact message
-        if (this.promptDefaults[promptMessage] !== undefined) {
-            return this.promptDefaults[promptMessage];
-        }
-        // Then check by prompt type
-        if (this.promptDefaults[promptType] !== undefined) {
-            return this.promptDefaults[promptType];
-        }
-        return undefined;
-    }
-    writeJson(data) {
-        this.output.write(JSON.stringify(data) + '\n');
-    }
-}

package/dist/server/infra/workspace/workspace-detector-service.d.ts

@@ -1,57 +0,0 @@
-import type { Agent } from '../../core/domain/entities/agent.js';
-import type { IWorkspaceDetectorService, WorkspaceInfo } from '../../core/interfaces/services/i-workspace-detector-service.js';
-/**
- * Service to detect IDE workspaces that contain the current working directory
- * Supports: VS Code (Github Copilot), Cursor, Claude, and Codex
- */
-export declare class WorkspaceDetectorService implements IWorkspaceDetectorService {
-    private readonly claudeUserPath;
-    private readonly codexUserPath;
-    private readonly cursorUserPath;
-    private readonly cwd;
-    private readonly vscodeUserPath;
-    constructor(cwd?: string);
-    /**
-     * Detect workspaces for the given IDE
-     *
-     * Supports: Github Copilot (VSCode), Cursor, Claude Code, Codex
-     *
-     * chatLogPath:
-     *   - For Cursor/VSCode: Path to workspace storage folder if workspace.json matches cwd
-     *   - For Claude Code: Path to claude project folder matching cwd (with special naming pattern)
-     *   - For Codex: Direct path to codex sessions folder
-     */
-    detectWorkspaces(agent: Agent): WorkspaceInfo;
-    /**
-     * Convert current working directory to Claude Code folder name format
-     * Example: /Users/datpham/dpmemories/byterover-cli -> -Users-datpham-dpmemories-byterover-cli
-     */
-    private cwdToClaudeFolderName;
-    /**
-     * Detect Claude Code workspaces
-     * Claude Code stores projects in ~/.claude/projects with folder names like "-Users-datpham-dpmemories-byterover-cli"
-     * These folder names are derived from the project path with slashes replaced by dashes
-     */
-    private detectClaudeWorkspaces;
-    /**
-     * Detect Codex workspaces
-     * Codex uses a single sessions folder
-     */
-    private detectCodexWorkspaces;
-    /**
-     * Detect Cursor workspaces
-     */
-    private detectCursorWorkspaces;
-    /**
-     * Detect VSCode workspaces (Github Copilot)
-     */
-    private detectVSCodeWorkspaces;
-    /**
-     * Detect workspaces using workspace.json file (VSCode, Cursor)
-     */
-    private detectWorkspacesByFile;
-    /**
-     * Check if current working directory is within the given workspace folder
-     */
-    private isCurrentDirInWorkspace;
-}

package/dist/server/infra/workspace/workspace-detector-service.js

@@ -1,165 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-/**
- * Service to detect IDE workspaces that contain the current working directory
- * Supports: VS Code (Github Copilot), Cursor, Claude, and Codex
- */
-export class WorkspaceDetectorService {
-    claudeUserPath;
-    codexUserPath;
-    cursorUserPath;
-    cwd;
-    vscodeUserPath;
-    constructor(cwd = process.cwd()) {
-        this.cwd = cwd;
-        this.vscodeUserPath = join(homedir(), 'Library/Application Support/Code/User/workspaceStorage');
-        this.cursorUserPath = join(homedir(), 'Library/Application Support/Cursor/User/workspaceStorage');
-        this.claudeUserPath = join(homedir(), '.claude/projects');
-        this.codexUserPath = join(homedir(), '.codex/sessions');
-    }
-    /**
-     * Detect workspaces for the given IDE
-     *
-     * Supports: Github Copilot (VSCode), Cursor, Claude Code, Codex
-     *
-     * chatLogPath:
-     *   - For Cursor/VSCode: Path to workspace storage folder if workspace.json matches cwd
-     *   - For Claude Code: Path to claude project folder matching cwd (with special naming pattern)
-     *   - For Codex: Direct path to codex sessions folder
-     */
-    detectWorkspaces(agent) {
-        const chatLogPath = '';
-        switch (agent) {
-            case 'Claude Code': {
-                return this.detectClaudeWorkspaces(chatLogPath);
-            }
-            case 'Codex': {
-                return this.detectCodexWorkspaces(chatLogPath);
-            }
-            case 'Cursor': {
-                return this.detectCursorWorkspaces(chatLogPath);
-            }
-            case 'Github Copilot': {
-                return this.detectVSCodeWorkspaces(chatLogPath);
-            }
-            default: {
-                return { chatLogPath, cwd: this.cwd };
-            }
-        }
-    }
-    /**
-     * Convert current working directory to Claude Code folder name format
-     * Example: /Users/datpham/dpmemories/byterover-cli -> -Users-datpham-dpmemories-byterover-cli
-     */
-    cwdToClaudeFolderName(cwd) {
-        // Remove leading slash and replace all slashes with dashes, then prepend dash
-        return '-' + cwd.slice(1).replaceAll('/', '-');
-    }
-    /**
-     * Detect Claude Code workspaces
-     * Claude Code stores projects in ~/.claude/projects with folder names like "-Users-datpham-dpmemories-byterover-cli"
-     * These folder names are derived from the project path with slashes replaced by dashes
-     */
-    detectClaudeWorkspaces(chatLogPath) {
-        try {
-            if (!existsSync(this.claudeUserPath)) {
-                return { chatLogPath, cwd: this.cwd };
-            }
-            // Convert cwd to Claude folder name format: /Users/datpham/dpmemories/byterover-cli -> -Users-datpham-dpmemories-byterover-cli
-            const claudeFolderName = this.cwdToClaudeFolderName(this.cwd);
-            const projectFolders = readdirSync(this.claudeUserPath);
-            for (const folderName of projectFolders) {
-                const folderPath = join(this.claudeUserPath, folderName);
-                // Check if this folder matches the current working directory
-                if (folderName === claudeFolderName) {
-                    chatLogPath = folderPath;
-                    break;
-                }
-            }
-        }
-        catch {
-            // Ignore directory read errors
-        }
-        return { chatLogPath, cwd: this.cwd };
-    }
-    /**
-     * Detect Codex workspaces
-     * Codex uses a single sessions folder
-     */
-    detectCodexWorkspaces(chatLogPath) {
-        try {
-            if (existsSync(this.codexUserPath)) {
-                chatLogPath = this.codexUserPath;
-            }
-        }
-        catch {
-            // Ignore errors
-        }
-        return { chatLogPath, cwd: this.cwd };
-    }
-    /**
-     * Detect Cursor workspaces
-     */
-    detectCursorWorkspaces(chatLogPath) {
-        return this.detectWorkspacesByFile(this.cursorUserPath, chatLogPath);
-    }
-    /**
-     * Detect VSCode workspaces (Github Copilot)
-     */
-    detectVSCodeWorkspaces(chatLogPath) {
-        return this.detectWorkspacesByFile(this.vscodeUserPath, chatLogPath);
-    }
-    /**
-     * Detect workspaces using workspace.json file (VSCode, Cursor)
-     */
-    detectWorkspacesByFile(userPath, chatLogPath) {
-        try {
-            if (!existsSync(userPath)) {
-                return { chatLogPath, cwd: this.cwd };
-            }
-            const workspaceIds = readdirSync(userPath);
-            for (const wsId of workspaceIds) {
-                const wsPath = join(userPath, wsId);
-                const workspaceFile = join(wsPath, 'workspace.json');
-                if (!existsSync(workspaceFile)) {
-                    continue;
-                }
-                try {
-                    const content = readFileSync(workspaceFile, 'utf8');
-                    const data = JSON.parse(content);
-                    // Only handle single folder windows (workspace files are ignored)
-                    if (!data.folder) {
-                        continue;
-                    }
-                    const folderPath = decodeURIComponent(data.folder.replace('file://', ''));
-                    // Set chatLogPath ONLY if folder exactly matches cwd
-                    if (folderPath === this.cwd) {
-                        chatLogPath = wsPath;
-                    }
-                }
-                catch {
-                    // Ignore JSON parse errors
-                }
-            }
-        }
-        catch {
-            // Ignore directory read errors
-        }
-        return { chatLogPath, cwd: this.cwd };
-    }
-    /**
-     * Check if current working directory is within the given workspace folder
-     */
-    isCurrentDirInWorkspace(folderPath) {
-        // Exact match
-        if (this.cwd === folderPath) {
-            return true;
-        }
-        // Check if current dir is a subdirectory
-        if (this.cwd.startsWith(folderPath + '/')) {
-            return true;
-        }
-        return false;
-    }
-}

package/dist/server/utils/crash-log.d.ts

@@ -1,14 +0,0 @@
-/**
- * Crash Log - Re-exports from unified process-logger.
- *
- * @deprecated Use crashLog from process-logger.ts directly.
- * This file is kept for backwards compatibility.
- */
-/**
- * @deprecated Use crashLog from process-logger.ts
- */
-export declare function writeCrashLog(error: Error | string, context?: string): Promise<string>;
-/**
- * @deprecated Use getSessionLogPath from process-logger.ts
- */
-export declare function getLogsDir(): string;

package/dist/server/utils/crash-log.js

@@ -1,19 +0,0 @@
-/**
- * Crash Log - Re-exports from unified process-logger.
- *
- * @deprecated Use crashLog from process-logger.ts directly.
- * This file is kept for backwards compatibility.
- */
-import { crashLog, getSessionLogPath } from './process-logger.js';
-/**
- * @deprecated Use crashLog from process-logger.ts
- */
-export async function writeCrashLog(error, context) {
-    return crashLog(error, context);
-}
-/**
- * @deprecated Use getSessionLogPath from process-logger.ts
- */
-export function getLogsDir() {
-    return getSessionLogPath();
-}