byterover-cli 0.2.0 → 0.3.0

package/dist/commands/complete.js

@@ -1,340 +0,0 @@
-import { Args, Command, Flags } from '@oclif/core';
-import { basename } from 'node:path';
-import { CuratorOutput } from '../core/domain/entities/curator-output.js';
-import { DeltaBatch } from '../core/domain/entities/delta-batch.js';
-import { ExecutorOutput } from '../core/domain/entities/executor-output.js';
-import { ReflectorOutput } from '../core/domain/entities/reflector-output.js';
-import { AcePromptTemplates } from '../infra/ace/ace-prompt-templates.js';
-import { FileDeltaStore } from '../infra/ace/file-delta-store.js';
-import { FileExecutorOutputStore } from '../infra/ace/file-executor-output-store.js';
-import { FilePlaybookStore } from '../infra/ace/file-playbook-store.js';
-import { FileReflectionStore } from '../infra/ace/file-reflection-store.js';
-import { FilePlaybookService } from '../infra/playbook/file-playbook-service.js';
-export default class Complete extends Command {
-    /* eslint-disable perfectionist/sort-objects */
-    static args = {
-        hint: Args.string({
-            description: 'Short hint for naming output files (e.g., "user-auth", "bug-fix")',
-            required: true,
-        }),
-        reasoning: Args.string({
-            description: 'Detailed reasoning and approach for completing the task',
-            required: true,
-        }),
-        finalAnswer: Args.string({
-            description: 'The final answer/solution to the task',
-            required: true,
-        }),
-    };
-    /* eslint-enable perfectionist/sort-objects */
-    static description = 'Complete ACE workflow: save executor output, generate reflection, and update playbook in one command';
-    static examples = [
-        String.raw `<%= config.bin %> <%= command.id %> "user-auth" "Implemented OAuth2 flow" "Auth works" --tool-usage "Read:src/auth.ts,Edit:src/auth.ts,Bash:npm test" --feedback "All tests passed"`,
-        String.raw `<%= config.bin %> <%= command.id %> "validation-fix" "Analyzed validator" "Fixed bug" --tool-usage "Grep:pattern:\"validate\",Read:src/validator.ts" --bullet-ids "bullet-123" --feedback "Tests passed"`,
-        String.raw `<%= config.bin %> <%= command.id %> "auth-update" "Improved error handling" "Better errors" --tool-usage "Edit:src/auth.ts" --feedback "Tests passed" --update-bullet "bullet-5"`,
-    ];
-    static flags = {
-        'bullet-ids': Flags.string({
-            char: 'b',
-            default: '',
-            description: 'Comma-separated list of playbook bullet IDs referenced',
-        }),
-        feedback: Flags.string({
-            char: 'f',
-            description: 'Environment feedback about task execution (e.g., "Tests passed", "Build failed")',
-            required: true,
-        }),
-        'tool-usage': Flags.string({
-            char: 't',
-            description: 'Comma-separated list of tool calls with arguments (format: "ToolName:argument", e.g., "Read:src/file.ts,Bash:npm test")',
-            required: true,
-        }),
-        'update-bullet': Flags.string({
-            char: 'u',
-            description: 'Bullet ID to update with new knowledge (if not provided, adds new bullet)',
-        }),
-    };
-    createServices() {
-        return {
-            deltaStore: new FileDeltaStore(),
-            executorOutputStore: new FileExecutorOutputStore(),
-            playbookService: new FilePlaybookService(),
-            promptBuilder: new AcePromptTemplates(),
-            reflectionStore: new FileReflectionStore(),
-        };
-    }
-    async run() {
-        const { args, flags } = await this.parse(Complete);
-        try {
-            const { deltaStore, executorOutputStore, playbookService, promptBuilder, reflectionStore } = this.createServices();
-            // Parse comma-separated lists
-            const bulletIds = this.parseBulletIds(flags['bullet-ids']);
-            const toolUsage = this.parseToolUsage(flags['tool-usage']);
-            // Phase 1: Executor
-            const saveResult = await this.saveExecutorOutput(executorOutputStore, args, bulletIds, toolUsage);
-            // Phase 2: Reflector
-            const { reflection, reflectionFilePath, tagsApplied } = await this.generateReflectionAndApplyTags({ playbookService, promptBuilder, reflectionStore }, saveResult.executorOutput, flags.feedback);
-            // Phase 3: Curator
-            const { curatorOutput, deltaFilePath } = await this.generateCurationAndApplyDelta({ deltaStore, playbookService, promptBuilder }, reflection, saveResult.executorOutput, flags);
-            // Display final summary
-            this.displayFinalSummary({
-                curatorOutput,
-                deltaFilePath,
-                executorPath: saveResult.filePath,
-                hint: args.hint,
-                reflectionFilePath,
-                tagsApplied,
-            });
-        }
-        catch (error) {
-            this.error(error instanceof Error ? error.message : 'Failed to complete ACE workflow');
-        }
-    }
-    /**
-     * Displays a formatted summary of the completed ACE workflow.
-     * Shows file paths, delta operations breakdown, and success confirmation.
-     *
-     * @param summary - Summary data containing all workflow outputs
-     * @param summary.curatorOutput - The curator output containing delta operations
-     * @param summary.deltaFilePath - Path to the saved delta file
-     * @param summary.executorPath - Path to the saved executor output file
-     * @param summary.hint - The hint used for naming output files
-     * @param summary.reflectionFilePath - Path to the saved reflection file
-     * @param summary.tagsApplied - Number of tags applied to the playbook
-     */
-    displayFinalSummary(summary) {
-        const { delta } = summary.curatorOutput;
-        const operationsByType = delta.getOperationsByType();
-        this.log('='.repeat(80));
-        this.log('✅ ACE WORKFLOW COMPLETED SUCCESSFULLY!');
-        this.log('='.repeat(80));
-        this.log('');
-        this.log('Summary:');
-        this.log(`  Hint: ${summary.hint}`);
-        this.log(`  Executor output: ${summary.executorPath}`);
-        this.log(`  Reflection: ${summary.reflectionFilePath}`);
-        this.log(`  Delta: ${summary.deltaFilePath}`);
-        this.log(`  Tags applied: ${summary.tagsApplied}`);
-        this.log('');
-        this.log('Delta operations:');
-        if (delta.isEmpty()) {
-            this.log('  - No operations (empty delta batch)');
-        }
-        else {
-            if (operationsByType.ADD) {
-                this.log(`  - ADD: ${operationsByType.ADD.length}`);
-            }
-            if (operationsByType.UPDATE) {
-                this.log(`  - UPDATE: ${operationsByType.UPDATE.length}`);
-            }
-            if (operationsByType.REMOVE) {
-                this.log(`  - REMOVE: ${operationsByType.REMOVE.length}`);
-            }
-            this.log(`  Total operations: ${delta.getOperationCount()}`);
-        }
-        this.log('');
-        this.log('🎉 Playbook has been updated with new knowledge!');
-    }
-    /**
-     * Extracts file paths from tool usage strings and formats them with project name prefix.
-     * Converts tool usage entries like "Read:src/file.ts" to "projectName/src/file.ts".
-     * Filters out non-file-like arguments (e.g., "Bash:npm test" is excluded).
-     *
-     * @param toolUsage - Array of tool usage strings (e.g., ["Read:src/file.ts", "Edit:src/other.ts"])
-     * @returns Array of formatted file paths with project name prefix
-     */
-    extractFilePaths(toolUsage) {
-        const cwd = process.cwd();
-        const projectName = basename(cwd);
-        return toolUsage
-            .map((usage) => {
-            const parts = usage.split(':');
-            if (parts.length <= 1)
-                return null;
-            const filePath = parts[1].trim();
-            // Filter out non-file-like paths (must contain / or . to be considered a file path)
-            if (!filePath.includes('/') && !filePath.includes('.')) {
-                return null;
-            }
-            // Remove leading ./ if present
-            const cleanPath = filePath.replace(/^\.\//, '');
-            // Combine project name with file path
-            const fullPath = `${projectName}/${cleanPath}`;
-            return fullPath;
-        })
-            .filter(Boolean);
-    }
-    /**
-     * Phase 3: Generates curation and applies delta operations to the playbook.
-     * Creates delta operations (ADD or UPDATE) based on reflection insights and applies them to the playbook.
-     *
-     * @param services - The service instances
-     * @param services.deltaStore - Delta store for persisting deltas
-     * @param services.playbookService - Playbook service for applying deltas
-     * @param services.promptBuilder - Prompt builder for curation prompts
-     * @param reflection - The reflection output from Phase 2
-     * @param executorOutput - The executor output from Phase 1
-     * @param flags - Command flags containing optional update-bullet ID
-     * @returns Object containing curator output and delta file path
-     */
-    async generateCurationAndApplyDelta(services, reflection, executorOutput, flags) {
-        this.log('🎨 Phase 3: Generating curation prompt...');
-        // Note: We load playbook temporarily just for validation
-        // The actual delta application will be done by playbookService
-        const tempStore = new FilePlaybookStore();
-        const updatedPlaybook = await tempStore.load();
-        if (!updatedPlaybook) {
-            this.error('Failed to reload playbook');
-        }
-        // Generate curation prompt (directly call promptBuilder instead of use case)
-        // Note: The prompt is generated but not currently used in this auto-generation flow
-        // In a full implementation, this would be sent to an LLM for processing
-        // services.promptBuilder.buildCuratorPrompt(reflection, updatedPlaybook, questionContext)
-        // Determine operation type based on --update-bullet flag
-        const updateBulletId = flags['update-bullet'];
-        let operationType = 'ADD';
-        // Validate bullet exists if UPDATE mode
-        if (updateBulletId) {
-            const bullet = updatedPlaybook.getBullet(updateBulletId);
-            if (!bullet) {
-                this.error(`Bullet with ID "${updateBulletId}" not found in playbook. Cannot update non-existent bullet.`);
-            }
-            operationType = 'UPDATE';
-            this.log(`  ℹ️  Updating existing bullet: ${updateBulletId}`);
-        }
-        else {
-            this.log('  ℹ️  Adding new bullet to playbook...');
-        }
-        // Auto-generate curator delta
-        const relatedFiles = this.extractFilePaths(executorOutput.toolUsage);
-        const curatorJson = {
-            operations: [
-                {
-                    bulletId: updateBulletId,
-                    content: reflection.keyInsight,
-                    metadata: {
-                        relatedFiles,
-                        tags: ['auto-generated'],
-                        timestamp: new Date().toISOString(),
-                    },
-                    section: 'Lessons Learned',
-                    type: operationType,
-                },
-            ],
-            reasoning: operationType === 'UPDATE'
-                ? `Updating bullet ${updateBulletId} with new insight: ${reflection.keyInsight}`
-                : `Adding key insight from task: ${reflection.keyInsight}`,
-        };
-        // Parse and save delta batch using service
-        const deltaBatch = DeltaBatch.fromJson(curatorJson);
-        const curatorOutput = new CuratorOutput(deltaBatch);
-        const deltaFilePath = await services.deltaStore.save(deltaBatch, reflection.hint);
-        // Apply delta operations using playbook service
-        const { operationsApplied } = await services.playbookService.applyDelta({ delta: curatorOutput.delta });
-        this.log(`  ✓ Delta saved: ${deltaFilePath}`);
-        this.log(`  ✓ Delta operations applied to playbook (${operationsApplied} operations)`);
-        this.log('');
-        return { curatorOutput, deltaFilePath };
-    }
-    /**
-     * Phase 2: Generates reflection based on executor output and applies tags to the playbook.
-     * Auto-generates reflection analysis from feedback and applies bullet tags to relevant playbook sections.
-     *
-     * @param services - The service instances
-     * @param services.playbookService - Playbook service for applying reflection tags
-     * @param services.promptBuilder - Prompt builder for reflection prompts
-     * @param services.reflectionStore - Reflection store for persisting reflections
-     * @param executorOutput - The executor output from Phase 1
-     * @param feedback - Environment feedback about task execution (e.g., "Tests passed", "Build failed")
-     * @returns Object containing reflection output, file path, and number of tags applied
-     */
-    async generateReflectionAndApplyTags(services, executorOutput, feedback) {
-        this.log('🤔 Phase 2: Generating reflection...');
-        // Note: We don't need to load playbook here anymore as applyReflectionTags handles it internally
-        // Generate reflection prompt (directly call promptBuilder instead of use case)
-        // Note: The prompt is generated but not currently used in this auto-generation flow
-        // In a full implementation, this would be sent to an LLM for processing
-        // const task = executorOutput.reasoning.split('\n')[0] || 'Task from executor'
-        // services.promptBuilder.buildReflectorPrompt(executorOutput, task, feedback, playbook, groundTruth)
-        // Auto-generate reflection based on feedback
-        this.log('  ℹ️  Auto-generating reflection based on feedback...');
-        const reflectionJson = {
-            bulletTags: [],
-            correctApproach: executorOutput.reasoning,
-            errorIdentification: feedback.toLowerCase().includes('fail') || feedback.toLowerCase().includes('error')
-                ? `Issues identified: ${feedback}`
-                : 'No critical errors identified',
-            hint: executorOutput.hint,
-            keyInsight: executorOutput.finalAnswer,
-            reasoning: `Analysis: ${feedback}. Approach: ${executorOutput.reasoning}`,
-            rootCauseAnalysis: feedback.toLowerCase().includes('fail') || feedback.toLowerCase().includes('error')
-                ? `Root cause requires investigation: ${feedback}`
-                : 'Successful execution without errors',
-        };
-        // Parse and save reflection using service
-        const reflection = ReflectorOutput.fromJson(reflectionJson);
-        const reflectionFilePath = await services.reflectionStore.save(reflection);
-        // Apply tags to playbook using playbook service
-        const { tagsApplied } = await services.playbookService.applyReflectionTags({ reflection });
-        this.log(`  ✓ Reflection saved: ${reflectionFilePath}`);
-        this.log(`  ✓ Tags applied to playbook: ${tagsApplied}`);
-        this.log('');
-        return { reflection, reflectionFilePath, tagsApplied };
-    }
-    /**
-     * Parses comma-separated bullet IDs string into an array of trimmed IDs.
-     * Empty strings and whitespace-only entries are filtered out.
-     *
-     * @param bulletIdsStr - Comma-separated string of bullet IDs (e.g., "bullet-1, bullet-2")
-     * @returns Array of trimmed bullet ID strings (empty array if input is empty string)
-     */
-    parseBulletIds(bulletIdsStr) {
-        return bulletIdsStr
-            .split(',')
-            .map((id) => id.trim())
-            .filter((id) => id.length > 0);
-    }
-    /**
-     * Parses comma-separated tool usage string into an array of trimmed entries.
-     * Empty strings and whitespace-only entries are filtered out.
-     *
-     * @param toolUsageStr - Comma-separated string of tool usage (e.g., "Read:file.ts, Edit:other.ts")
-     * @returns Array of trimmed tool usage strings
-     */
-    parseToolUsage(toolUsageStr) {
-        return toolUsageStr
-            .split(',')
-            .map((tool) => tool.trim())
-            .filter((tool) => tool.length > 0);
-    }
-    /**
-     * Phase 1: Saves executor output to a file.
-     * Creates an ExecutorOutput entity from command arguments and persists it using the executor output store service.
-     *
-     * @param executorOutputStore - The executor output store service
-     * @param args - Command arguments
-     * @param args.hint - Short hint for naming output files
-     * @param args.reasoning - Detailed reasoning and approach for completing the task
-     * @param args.finalAnswer - The final answer/solution to the task
-     * @param bulletIds - Array of playbook bullet IDs referenced during task execution
-     * @param toolUsage - Array of tool usage strings (e.g., ["Read:src/file.ts", "Bash:npm test"])
-     * @returns Object containing the executor output entity and file path where it was saved
-     */
-    async saveExecutorOutput(executorOutputStore, args, bulletIds, toolUsage) {
-        this.log('🚀 Starting ACE workflow...');
-        this.log('');
-        this.log('📝 Phase 1: Saving executor output...');
-        const executorOutput = new ExecutorOutput({
-            bulletIds,
-            finalAnswer: args.finalAnswer,
-            hint: args.hint,
-            reasoning: args.reasoning,
-            toolUsage,
-        });
-        // Save executor output using service
-        const filePath = await executorOutputStore.save(executorOutput);
-        this.log(`  ✓ Executor output saved: ${filePath}`);
-        this.log('');
-        return { executorOutput, filePath };
-    }
-}

package/dist/commands/retrieve.d.ts

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

package/dist/commands/retrieve.js

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

package/dist/core/domain/entities/curator-output.d.ts

@@ -1,14 +0,0 @@
-import { DeltaBatch, type DeltaBatchJson } from './delta-batch.js';
-/**
- * Output from the curator phase.
- * Contains the delta operations to apply to the playbook.
- */
-export declare class CuratorOutput {
-    readonly delta: DeltaBatch;
-    constructor(delta: DeltaBatch);
-    /**
-     * Creates a CuratorOutput instance from a JSON object
-     */
-    static fromJson(json: DeltaBatchJson): CuratorOutput;
-    toJson(): DeltaBatchJson;
-}

package/dist/core/domain/entities/curator-output.js

@@ -1,23 +0,0 @@
-import { DeltaBatch } from './delta-batch.js';
-/**
- * Output from the curator phase.
- * Contains the delta operations to apply to the playbook.
- */
-export class CuratorOutput {
-    delta;
-    constructor(delta) {
-        this.delta = delta;
-    }
-    /**
-     * Creates a CuratorOutput instance from a JSON object
-     */
-    static fromJson(json) {
-        const delta = DeltaBatch.fromJson(json);
-        return new CuratorOutput(delta);
-    }
-    toJson() {
-        return {
-            ...this.delta.toJson()
-        };
-    }
-}

package/dist/core/domain/entities/delta-batch.d.ts

@@ -1,30 +0,0 @@
-import { DeltaOperation, type DeltaOperationJson, type OperationType } from './delta-operation.js';
-export interface DeltaBatchJson {
-    operations: DeltaOperationJson[];
-    reasoning: string;
-}
-/**
- * Represents a batch of delta operations with curator reasoning.
- */
-export declare class DeltaBatch {
-    readonly operations: DeltaOperation[];
-    readonly reasoning: string;
-    constructor(reasoning: string, operations: DeltaOperation[]);
-    /**
-     * Creates a DeltaBatch instance from a JSON object
-     */
-    static fromJson(json: DeltaBatchJson): DeltaBatch;
-    /**
-     * Returns the count of operations
-     */
-    getOperationCount(): number;
-    /**
-     * Returns operations grouped by type
-     */
-    getOperationsByType(): Record<OperationType, DeltaOperation[]>;
-    /**
-     * Returns true if the batch has no operations
-     */
-    isEmpty(): boolean;
-    toJson(): DeltaBatchJson;
-}

package/dist/core/domain/entities/delta-batch.js

@@ -1,52 +0,0 @@
-import { DeltaOperation } from './delta-operation.js';
-/**
- * Represents a batch of delta operations with curator reasoning.
- */
-export class DeltaBatch {
-    operations;
-    reasoning;
-    constructor(reasoning, operations) {
-        if (reasoning.trim().length === 0) {
-            throw new Error('Delta batch reasoning cannot be empty');
-        }
-        this.reasoning = reasoning;
-        this.operations = [...operations];
-    }
-    /**
-     * Creates a DeltaBatch instance from a JSON object
-     */
-    static fromJson(json) {
-        const operations = (json.operations ?? []).map((op) => DeltaOperation.fromJson(op));
-        return new DeltaBatch(json.reasoning, operations);
-    }
-    /**
-     * Returns the count of operations
-     */
-    getOperationCount() {
-        return this.operations.length;
-    }
-    /**
-     * Returns operations grouped by type
-     */
-    getOperationsByType() {
-        const result = {};
-        for (const op of this.operations) {
-            if (!result[op.type])
-                result[op.type] = [];
-            result[op.type].push(op);
-        }
-        return result;
-    }
-    /**
-     * Returns true if the batch has no operations
-     */
-    isEmpty() {
-        return this.operations.length === 0;
-    }
-    toJson() {
-        return {
-            operations: this.operations.map((op) => op.toJson()),
-            reasoning: this.reasoning,
-        };
-    }
-}

package/dist/core/domain/entities/delta-operation.d.ts

@@ -1,31 +0,0 @@
-import type { BulletMetadata } from './bullet.js';
-export type OperationType = 'ADD' | 'REMOVE' | 'UPDATE';
-interface DeltaOperationOptions {
-    bulletId?: string;
-    content?: string;
-    metadata?: BulletMetadata;
-}
-export interface DeltaOperationJson {
-    bulletId?: string;
-    content?: string;
-    metadata?: BulletMetadata;
-    section: string;
-    type: OperationType;
-}
-/**
- * Represents a single change operation to apply to a playbook.
- */
-export declare class DeltaOperation {
-    readonly bulletId?: string;
-    readonly content?: string;
-    readonly metadata?: BulletMetadata;
-    readonly section: string;
-    readonly type: OperationType;
-    constructor(type: OperationType, section: string, options?: DeltaOperationOptions);
-    /**
-     * Creates a DeltaOperation instance from a JSON object
-     */
-    static fromJson(json: DeltaOperationJson): DeltaOperation;
-    toJson(): DeltaOperationJson;
-}
-export {};

package/dist/core/domain/entities/delta-operation.js

@@ -1,50 +0,0 @@
-/**
- * Represents a single change operation to apply to a playbook.
- */
-export class DeltaOperation {
-    bulletId;
-    content;
-    metadata;
-    section;
-    type;
-    constructor(type, section, options = {}) {
-        const { bulletId, content, metadata } = options;
-        if (type === 'ADD' && !content) {
-            throw new Error('ADD operation requires content');
-        }
-        if (type === 'UPDATE' && !bulletId) {
-            throw new Error('UPDATE operation requires bulletId');
-        }
-        if (type === 'REMOVE' && !bulletId) {
-            throw new Error('REMOVE operation requires bulletId');
-        }
-        this.type = type;
-        this.section = section;
-        this.content = content;
-        this.bulletId = bulletId;
-        this.metadata = metadata;
-    }
-    /**
-     * Creates a DeltaOperation instance from a JSON object
-     */
-    static fromJson(json) {
-        return new DeltaOperation(json.type, json.section, {
-            bulletId: json.bulletId,
-            content: json.content,
-            metadata: json.metadata,
-        });
-    }
-    toJson() {
-        const result = {
-            section: this.section,
-            type: this.type,
-        };
-        if (this.content !== undefined)
-            result.content = this.content;
-        if (this.bulletId !== undefined)
-            result.bulletId = this.bulletId;
-        if (this.metadata !== undefined)
-            result.metadata = this.metadata;
-        return result;
-    }
-}