byterover-cli 0.1.0

package/dist/core/domain/entities/bullet.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Represents metadata associated with a bullet point
+ */
+export interface BulletMetadata {
+    relatedFiles: string[];
+    tags: string[];
+    timestamp: string;
+}
+export interface BulletJson {
+    content?: string;
+    id: string;
+    memoryId?: string;
+    metadata: {
+        relatedFiles: string[];
+        tags: string[];
+        timestamp: string;
+    };
+    section: string;
+}
+/**
+ * Represents a single knowledge entry in the playbook.
+ * Bullets contain reusable insights, strategies, or lessons learned.
+ */
+export declare class Bullet {
+    readonly content: string;
+    readonly id: string;
+    readonly memoryId?: string;
+    readonly metadata: BulletMetadata;
+    readonly section: string;
+    constructor(id: string, section: string, content: string, metadata: BulletMetadata, memoryId?: string);
+    /**
+     * Creates a Bullet instance from a JSON object.
+     * The content parameter must be provided separately when content is stored in files.
+     * @param json The JSON object containing bullet metadata
+     * @param content Optional content string (required if json.content is undefined)
+     */
+    static fromJson(json: BulletJson, content?: string): Bullet;
+    /**
+     * Formats the bullet for display in a playbook
+     */
+    toDisplayString(): string;
+    /**
+     * Converts the bullet to a JSON object
+     * @param includeContent If false, content field is omitted (for file-based storage)
+     */
+    toJson(includeContent?: boolean): BulletJson;
+    /**
+     * Creates a new bullet with updated content
+     */
+    withUpdatedContent(content: string): Bullet;
+}

package/dist/core/domain/entities/bullet.js

@@ -0,0 +1,94 @@
+/**
+ * Represents a single knowledge entry in the playbook.
+ * Bullets contain reusable insights, strategies, or lessons learned.
+ */
+export class Bullet {
+    content;
+    id;
+    memoryId;
+    metadata;
+    section;
+    // eslint-disable-next-line max-params
+    constructor(id, section, content, metadata, memoryId) {
+        if (id.trim().length === 0) {
+            throw new Error('Bullet ID cannot be empty');
+        }
+        if (section.trim().length === 0) {
+            throw new Error('Bullet section cannot be empty');
+        }
+        if (content.trim().length === 0) {
+            throw new Error('Bullet content cannot be empty');
+        }
+        if (!metadata.timestamp || metadata.timestamp.trim().length === 0) {
+            throw new Error('Bullet metadata timestamp cannot be empty');
+        }
+        if (!metadata.relatedFiles || !Array.isArray(metadata.relatedFiles)) {
+            throw new Error('Bullet metadata relatedFiles must be an array');
+        }
+        if (!metadata.tags || metadata.tags.length === 0) {
+            throw new Error('Bullet metadata tags cannot be empty');
+        }
+        this.id = id;
+        this.section = section;
+        this.content = content;
+        this.metadata = metadata;
+        this.memoryId = memoryId;
+    }
+    /**
+     * Creates a Bullet instance from a JSON object.
+     * The content parameter must be provided separately when content is stored in files.
+     * @param json The JSON object containing bullet metadata
+     * @param content Optional content string (required if json.content is undefined)
+     */
+    static fromJson(json, content) {
+        const bulletContent = json.content ?? content;
+        if (!bulletContent) {
+            throw new Error(`Bullet content is required for bullet ${json.id}`);
+        }
+        return new Bullet(json.id, json.section, bulletContent, {
+            relatedFiles: json.metadata.relatedFiles,
+            tags: json.metadata.tags,
+            timestamp: json.metadata.timestamp,
+        }, json.memoryId);
+    }
+    /**
+     * Formats the bullet for display in a playbook
+     */
+    toDisplayString() {
+        const tags = this.metadata.tags.join(', ');
+        const tagDisplay = `[Tags: ${tags}]`;
+        const filesDisplay = this.metadata.relatedFiles.length > 0 ? `[Files: ${this.metadata.relatedFiles.join(', ')}]` : '[Files: none]';
+        const timestampDisplay = `[Updated: ${this.metadata.timestamp}]`;
+        const metadataDisplay = [tagDisplay, filesDisplay, timestampDisplay].join(' ');
+        return `- [${this.id}] ${this.content}\n  ${this.section}\n  ${metadataDisplay}`;
+    }
+    /**
+     * Converts the bullet to a JSON object
+     * @param includeContent If false, content field is omitted (for file-based storage)
+     */
+    toJson(includeContent = true) {
+        const json = {
+            id: this.id,
+            memoryId: this.memoryId,
+            metadata: {
+                relatedFiles: this.metadata.relatedFiles,
+                tags: this.metadata.tags,
+                timestamp: this.metadata.timestamp,
+            },
+            section: this.section,
+        };
+        if (includeContent) {
+            json.content = this.content;
+        }
+        return json;
+    }
+    /**
+     * Creates a new bullet with updated content
+     */
+    withUpdatedContent(content) {
+        return new Bullet(this.id, this.section, content, {
+            ...this.metadata,
+            timestamp: new Date().toISOString(),
+        }, this.memoryId);
+    }
+}

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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,50 @@
+/**
+ * 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;
+    }
+}

package/dist/core/domain/entities/event.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Array of all supported Events.
+ */
+export declare const EVENT_VALUES: readonly ["auth:signed_in", "space:init", "space:changed", "rule:generate", "ace:add_bullet", "ace:update_bullet", "ace:remove_bullet", "ace:view_status", "mem:push", "mem:retrieve"];
+export type EventName = (typeof EVENT_VALUES)[number];
+export interface PropertyDict {
+    [key: string]: any;
+}

package/dist/core/domain/entities/event.js

@@ -0,0 +1,15 @@
+/**
+ * Array of all supported Events.
+ */
+export const EVENT_VALUES = [
+    'auth:signed_in',
+    'space:init',
+    'space:changed',
+    'rule:generate',
+    'ace:add_bullet',
+    'ace:update_bullet',
+    'ace:remove_bullet',
+    'ace:view_status',
+    'mem:push',
+    'mem:retrieve',
+];

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

@@ -0,0 +1,27 @@
+export interface ExecutorOutputJson {
+    bulletIds: string[];
+    finalAnswer: string;
+    hint: string;
+    reasoning: string;
+    toolUsage: string[];
+}
+export interface ExecutorOutputOptions {
+    bulletIds?: string[];
+    finalAnswer: string;
+    hint: string;
+    reasoning: string;
+    toolUsage?: string[];
+}
+/**
+ * Output from the executor (the coding agent) phase.
+ * Contains reasoning, final answer, and bullets referenced.
+ */
+export declare class ExecutorOutput {
+    readonly bulletIds: string[];
+    readonly finalAnswer: string;
+    readonly hint: string;
+    readonly reasoning: string;
+    readonly toolUsage: string[];
+    constructor(options: ExecutorOutputOptions);
+    toJson(): ExecutorOutputJson;
+}

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

@@ -0,0 +1,33 @@
+/**
+ * Output from the executor (the coding agent) phase.
+ * Contains reasoning, final answer, and bullets referenced.
+ */
+export class ExecutorOutput {
+    bulletIds;
+    finalAnswer;
+    hint;
+    reasoning;
+    toolUsage;
+    constructor(options) {
+        if (options.reasoning.trim().length === 0) {
+            throw new Error('Executor reasoning cannot be empty');
+        }
+        if (options.finalAnswer.trim().length === 0) {
+            throw new Error('Executor final answer cannot be empty');
+        }
+        this.hint = options.hint;
+        this.reasoning = options.reasoning;
+        this.finalAnswer = options.finalAnswer;
+        this.bulletIds = [...(options.bulletIds ?? [])];
+        this.toolUsage = [...(options.toolUsage ?? [])];
+    }
+    toJson() {
+        return {
+            bulletIds: this.bulletIds,
+            finalAnswer: this.finalAnswer,
+            hint: this.hint,
+            reasoning: this.reasoning,
+            toolUsage: this.toolUsage,
+        };
+    }
+}

package/dist/core/domain/entities/memory.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Parameters for creating a Memory instance.
+ *
+ * Note: score, parentIds, and childrenIds are optional.
+ * These fields are present in primary memories (from the `memories` array)
+ * but absent in related memories (from the `related_memories` array).
+ */
+export type MemoryParams = {
+    bulletId: string;
+    childrenIds?: string[];
+    content: string;
+    id: string;
+    metadataType: string;
+    nodeKeys: string[];
+    parentIds?: string[];
+    score?: number;
+    section: string;
+    tags: string[];
+    timestamp: string;
+    title: string;
+};
+/**
+ * Represents a memory retrieved from the ByteRover Memora service.
+ * Memories are hierarchical knowledge fragments that can have parent and child relationships.
+ *
+ * Note: score, parentIds, and childrenIds are optional fields.
+ * - Primary memories (from API `memories` array) have these fields
+ * - Related memories (from API `related_memories` array) don't have these fields
+ */
+export declare class Memory {
+    readonly bulletId: string;
+    readonly childrenIds?: readonly string[];
+    readonly content: string;
+    readonly id: string;
+    readonly metadataType: string;
+    readonly nodeKeys: readonly string[];
+    readonly parentIds?: readonly string[];
+    readonly score?: number;
+    readonly section: string;
+    readonly tags: readonly string[];
+    readonly timestamp: string;
+    readonly title: string;
+    constructor(params: MemoryParams);
+    /**
+     * Creates a Memory instance from a JSON object.
+     * @param json JSON object representing the Memory
+     * @returns An instance of Memory
+     */
+    static fromJson(json: MemoryParams): Memory;
+    /**
+     * Converts the Memory instance to a JSON object.
+     * @returns A JSON object representing the Memory
+     */
+    toJson(): MemoryParams;
+}

package/dist/core/domain/entities/memory.js

@@ -0,0 +1,90 @@
+/**
+ * Represents a memory retrieved from the ByteRover Memora service.
+ * Memories are hierarchical knowledge fragments that can have parent and child relationships.
+ *
+ * Note: score, parentIds, and childrenIds are optional fields.
+ * - Primary memories (from API `memories` array) have these fields
+ * - Related memories (from API `related_memories` array) don't have these fields
+ */
+export class Memory {
+    bulletId;
+    childrenIds;
+    content;
+    id;
+    metadataType;
+    nodeKeys;
+    parentIds;
+    score;
+    section;
+    tags;
+    timestamp;
+    title;
+    constructor(params) {
+        if (params.id.trim().length === 0) {
+            throw new Error('Memory ID cannot be empty');
+        }
+        if (params.bulletId.trim().length === 0) {
+            throw new Error('Memory bulletId cannot be empty');
+        }
+        if (params.title.trim().length === 0) {
+            throw new Error('Memory title cannot be empty');
+        }
+        if (params.content.trim().length === 0) {
+            throw new Error('Memory content cannot be empty');
+        }
+        if (params.section.trim().length === 0) {
+            throw new Error('Memory section cannot be empty');
+        }
+        if (params.timestamp.trim().length === 0) {
+            throw new Error('Memory timestamp cannot be empty');
+        }
+        if (params.metadataType.trim().length === 0) {
+            throw new Error('Memory metadataType cannot be empty');
+        }
+        // Only validate score if it's provided (primary memories have score, related memories don't)
+        if (params.score !== undefined && (params.score < 0 || params.score > 1)) {
+            throw new Error('Memory score must be between 0.0 and 1.0');
+        }
+        this.id = params.id;
+        this.bulletId = params.bulletId;
+        this.title = params.title;
+        this.content = params.content;
+        this.score = params.score;
+        this.section = params.section;
+        this.metadataType = params.metadataType;
+        this.timestamp = params.timestamp;
+        // Defensive copy to prevent external mutation
+        this.nodeKeys = [...params.nodeKeys];
+        this.parentIds = params.parentIds ? [...params.parentIds] : undefined;
+        this.childrenIds = params.childrenIds ? [...params.childrenIds] : undefined;
+        this.tags = [...params.tags];
+    }
+    /**
+     * Creates a Memory instance from a JSON object.
+     * @param json JSON object representing the Memory
+     * @returns An instance of Memory
+     */
+    static fromJson(json) {
+        return new Memory(json);
+    }
+    /**
+     * Converts the Memory instance to a JSON object.
+     * @returns A JSON object representing the Memory
+     */
+    toJson() {
+        return {
+            bulletId: this.bulletId,
+            ...(this.childrenIds !== undefined && { childrenIds: [...this.childrenIds] }),
+            content: this.content,
+            id: this.id,
+            metadataType: this.metadataType,
+            nodeKeys: [...this.nodeKeys],
+            ...(this.parentIds !== undefined && { parentIds: [...this.parentIds] }),
+            ...(this.score !== undefined && { score: this.score }),
+            section: this.section,
+            tags: [...this.tags],
+            timestamp: this.timestamp,
+            title: this.title,
+        };
+    }
+}

package/dist/core/domain/entities/oauth-token-data.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Represents OAuth token data returned from the authorization server.
+ * This is an intermediate type that does not include user information.
+ * The login command will combine this with user data to create a complete AuthToken.
+ */
+export declare class OAuthTokenData {
+    readonly accessToken: string;
+    readonly expiresAt: Date;
+    readonly refreshToken: string;
+    readonly sessionKey: string;
+    readonly tokenType: string;
+    constructor(accessToken: string, expiresAt: Date, refreshToken: string, sessionKey: string, tokenType?: string);
+}

package/dist/core/domain/entities/oauth-token-data.js

@@ -0,0 +1,20 @@
+/**
+ * Represents OAuth token data returned from the authorization server.
+ * This is an intermediate type that does not include user information.
+ * The login command will combine this with user data to create a complete AuthToken.
+ */
+export class OAuthTokenData {
+    accessToken;
+    expiresAt;
+    refreshToken;
+    sessionKey;
+    tokenType;
+    // eslint-disable-next-line max-params
+    constructor(accessToken, expiresAt, refreshToken, sessionKey, tokenType = 'Bearer') {
+        this.accessToken = accessToken;
+        this.expiresAt = expiresAt;
+        this.refreshToken = refreshToken;
+        this.sessionKey = sessionKey;
+        this.tokenType = tokenType;
+    }
+}