byterover-cli 0.2.0 → 0.3.0

package/dist/core/domain/entities/brv-config.d.ts

@@ -1,25 +1,61 @@
+import { Agent } from './agent.js';
 import { Space } from './space.js';
+/**
+ * Parameters for creating a BrvConfig instance.
+ */
+export type BrvConfigParams = {
+    chatLogPath: string;
+    cipherAgentContext?: string;
+    cipherAgentModes?: string[];
+    cipherAgentSystemPrompt?: string;
+    createdAt: string;
+    cwd: string;
+    ide: Agent;
+    spaceId: string;
+    spaceName: string;
+    teamId: string;
+    teamName: string;
+    version: string;
+};
+/**
+ * Parameters for creating a BrvConfig from a Space entity.
+ */
+export type FromSpaceParams = {
+    chatLogPath: string;
+    cwd: string;
+    ide: Agent;
+    space: Space;
+};
 /**
  * Represents the configuration stored in .brv/config.json
  * This config links a project directory to a ByteRover space.
  */
 export declare class BrvConfig {
+    readonly chatLogPath: string;
+    readonly cipherAgentContext?: string;
+    readonly cipherAgentModes?: string[];
+    readonly cipherAgentSystemPrompt?: string;
     readonly createdAt: string;
+    readonly cwd: string;
+    readonly ide: Agent;
     readonly spaceId: string;
     readonly spaceName: string;
     readonly teamId: string;
     readonly teamName: string;
-    constructor(createdAt: string, spaceId: string, spaceName: string, teamId: string, teamName: string);
+    readonly version: string;
+    constructor(params: BrvConfigParams);
     /**
-     * Deserializes config from JSON format
+     * Deserializes config from JSON format.
+     * @throws Error if the JSON structure is invalid.
+     * @throws BrvConfigVersionError if version is missing or mismatched.
      */
-    static fromJson(json: Record<string, string>): BrvConfig;
+    static fromJson(json: unknown): BrvConfig;
     /**
-     * Creates a BrvConfig from a Space entity
+     * Creates a BrvConfig from a Space entity.
      */
-    static fromSpace(space: Space): BrvConfig;
+    static fromSpace(params: FromSpaceParams): BrvConfig;
     /**
      * Serializes the config to JSON format
      */
-    toJson(): Record<string, string>;
+    toJson(): Record<string, unknown>;
 }

package/dist/core/domain/entities/brv-config.js

@@ -1,58 +1,156 @@
+import { BRV_CONFIG_VERSION } from '../../../constants.js';
+import { BrvConfigVersionError } from '../errors/brv-config-version-error.js';
+import { AGENT_VALUES } from './agent.js';
+/**
+ * Type guard for Agent validation
+ */
+const isCodingAgent = (value) => {
+    if (typeof value !== 'string')
+        return false;
+    for (const agent of AGENT_VALUES) {
+        if (agent === value)
+            return true;
+    }
+    return false;
+};
+/**
+ * Type guard for BrvConfigFromJson - validates JSON structure at runtime.
+ * Note: version is optional in this check (old configs may not have it).
+ */
+const isBrvConfigJson = (json) => {
+    if (typeof json !== 'object' || json === null)
+        return false;
+    const requiredInputJsonKeys = [
+        'chatLogPath',
+        'createdAt',
+        'cwd',
+        'spaceId',
+        'spaceName',
+        'teamId',
+        'teamName',
+    ];
+    for (const key of requiredInputJsonKeys) {
+        if (!(key in json) || typeof json[key] !== 'string') {
+            return false;
+        }
+    }
+    if (!('ide' in json) || !isCodingAgent(json.ide)) {
+        return false;
+    }
+    // Check optional fields if present
+    const obj = json;
+    if (obj.cipherAgentContext !== undefined && typeof obj.cipherAgentContext !== 'string')
+        return false;
+    if (obj.cipherAgentSystemPrompt !== undefined && typeof obj.cipherAgentSystemPrompt !== 'string')
+        return false;
+    if (obj.cipherAgentModes !== undefined && !Array.isArray(obj.cipherAgentModes))
+        return false;
+    if (obj.version !== undefined && typeof obj.version !== 'string')
+        return false;
+    return true;
+};
 /**
  * Represents the configuration stored in .brv/config.json
  * This config links a project directory to a ByteRover space.
  */
 export class BrvConfig {
+    chatLogPath;
+    cipherAgentContext;
+    cipherAgentModes;
+    cipherAgentSystemPrompt;
     createdAt;
+    cwd;
+    ide;
     spaceId;
     spaceName;
     teamId;
     teamName;
-    // eslint-disable-next-line max-params
-    constructor(createdAt, spaceId, spaceName, teamId, teamName) {
-        if (createdAt.trim().length === 0) {
+    version;
+    constructor(params) {
+        if (params.createdAt.trim().length === 0) {
             throw new Error('Created at cannot be empty');
         }
-        if (spaceId.trim().length === 0) {
+        if (params.spaceId.trim().length === 0) {
             throw new Error('Space ID cannot be empty');
         }
-        if (spaceName.trim().length === 0) {
+        if (params.spaceName.trim().length === 0) {
             throw new Error('Space name cannot be empty');
         }
-        if (teamId.trim().length === 0) {
+        if (params.teamId.trim().length === 0) {
             throw new Error('Team ID cannot be empty');
         }
-        if (teamName.trim().length === 0) {
+        if (params.teamName.trim().length === 0) {
             throw new Error('Team name cannot be empty');
         }
-        this.createdAt = createdAt;
-        this.spaceId = spaceId;
-        this.spaceName = spaceName;
-        this.teamId = teamId;
-        this.teamName = teamName;
+        this.chatLogPath = params.chatLogPath;
+        this.cipherAgentContext = params.cipherAgentContext;
+        this.cipherAgentModes = params.cipherAgentModes;
+        this.cipherAgentSystemPrompt = params.cipherAgentSystemPrompt;
+        this.createdAt = params.createdAt;
+        this.cwd = params.cwd;
+        this.ide = params.ide;
+        this.spaceId = params.spaceId;
+        this.spaceName = params.spaceName;
+        this.teamId = params.teamId;
+        this.teamName = params.teamName;
+        this.version = params.version;
     }
     /**
-     * Deserializes config from JSON format
+     * Deserializes config from JSON format.
+     * @throws Error if the JSON structure is invalid.
+     * @throws BrvConfigVersionError if version is missing or mismatched.
      */
     static fromJson(json) {
-        return new BrvConfig(json.createdAt, json.spaceId, json.spaceName, json.teamId, json.teamName);
+        if (!isBrvConfigJson(json)) {
+            throw new Error('Invalid BrvConfig JSON structure');
+        }
+        if (json.version === undefined) {
+            throw new BrvConfigVersionError({
+                currentVersion: undefined,
+                expectedVersion: BRV_CONFIG_VERSION,
+            });
+        }
+        if (json.version !== BRV_CONFIG_VERSION) {
+            throw new BrvConfigVersionError({
+                currentVersion: json.version,
+                expectedVersion: BRV_CONFIG_VERSION,
+            });
+        }
+        return new BrvConfig({ ...json, version: json.version });
     }
     /**
-     * Creates a BrvConfig from a Space entity
+     * Creates a BrvConfig from a Space entity.
      */
-    static fromSpace(space) {
-        return new BrvConfig(new Date().toISOString(), space.id, space.name, space.teamId, space.teamName);
+    static fromSpace(params) {
+        return new BrvConfig({
+            chatLogPath: params.chatLogPath,
+            createdAt: new Date().toISOString(),
+            cwd: params.cwd,
+            ide: params.ide,
+            spaceId: params.space.id,
+            spaceName: params.space.name,
+            teamId: params.space.teamId,
+            teamName: params.space.teamName,
+            version: BRV_CONFIG_VERSION,
+        });
     }
     /**
      * Serializes the config to JSON format
      */
     toJson() {
         return {
+            chatLogPath: this.chatLogPath,
+            cipherAgentContext: this.cipherAgentContext,
+            cipherAgentModes: this.cipherAgentModes,
+            cipherAgentSystemPrompt: this.cipherAgentSystemPrompt,
             createdAt: this.createdAt,
+            cwd: this.cwd,
+            ide: this.ide,
             spaceId: this.spaceId,
             spaceName: this.spaceName,
             teamId: this.teamId,
             teamName: this.teamName,
+            version: this.version,
         };
     }
 }

package/dist/core/domain/entities/cogit-push-context.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Valid operation types for CoGit push context.
+ */
+export type ContextOperation = 'add' | 'delete' | 'edit';
+/**
+ * Parameters for creating a CogitPushContext instance.
+ */
+export type CogitPushContextParams = {
+    content: string;
+    operation: ContextOperation;
+    path: string;
+    tags: string[];
+    title: string;
+};
+/**
+ * Represents a single context file operation in a CoGit push.
+ * Used for adding, editing, or deleting context files.
+ */
+export declare class CogitPushContext {
+    readonly content: string;
+    readonly operation: ContextOperation;
+    readonly path: string;
+    readonly tags: readonly string[];
+    readonly title: string;
+    constructor(params: CogitPushContextParams);
+    /**
+     * Creates a CogitPushContext instance from a JSON object.
+     * @param json JSON object representing the context
+     * @returns An instance of CogitPushContext
+     * @throws TypeError if required fields are missing or have invalid types
+     */
+    static fromJson(json: unknown): CogitPushContext;
+    /**
+     * Converts the CogitPushContext instance to a JSON object for the API.
+     * @returns A JSON object for API serialization
+     */
+    toJson(): Record<string, unknown>;
+}

package/dist/core/domain/entities/cogit-push-context.js

@@ -0,0 +1,91 @@
+/**
+ * Type guard to validate operation type.
+ */
+const isValidOperation = (operation) => operation === 'add' || operation === 'edit' || operation === 'delete';
+/**
+ * Represents a single context file operation in a CoGit push.
+ * Used for adding, editing, or deleting context files.
+ */
+export class CogitPushContext {
+    content;
+    operation;
+    path;
+    tags;
+    title;
+    constructor(params) {
+        if (!isValidOperation(params.operation)) {
+            throw new Error(`Invalid operation: ${params.operation}. Must be 'add', 'edit', or 'delete'`);
+        }
+        if (params.path.trim().length === 0) {
+            throw new Error('CogitPushContext path cannot be empty');
+        }
+        // For 'add' operation, content and title are required
+        if (params.operation === 'add') {
+            if (params.content.trim().length === 0) {
+                throw new Error('CogitPushContext content cannot be empty for add operation');
+            }
+            if (params.title.trim().length === 0) {
+                throw new Error('CogitPushContext title cannot be empty for add operation');
+            }
+        }
+        this.operation = params.operation;
+        this.path = params.path;
+        this.title = params.title;
+        this.content = params.content;
+        // Defensive copy to prevent external mutation
+        this.tags = [...params.tags];
+    }
+    /**
+     * Creates a CogitPushContext instance from a JSON object.
+     * @param json JSON object representing the context
+     * @returns An instance of CogitPushContext
+     * @throws TypeError if required fields are missing or have invalid types
+     */
+    static fromJson(json) {
+        if (!json || typeof json !== 'object') {
+            throw new TypeError('CogitPushContext JSON must be an object');
+        }
+        const obj = json;
+        if (typeof obj.operation !== 'string') {
+            throw new TypeError('CogitPushContext JSON must have a string operation field');
+        }
+        if (typeof obj.path !== 'string') {
+            throw new TypeError('CogitPushContext JSON must have a string path field');
+        }
+        if (typeof obj.title !== 'string') {
+            throw new TypeError('CogitPushContext JSON must have a string title field');
+        }
+        if (typeof obj.content !== 'string') {
+            throw new TypeError('CogitPushContext JSON must have a string content field');
+        }
+        if (!Array.isArray(obj.tags)) {
+            throw new TypeError('CogitPushContext JSON must have a tags array');
+        }
+        const tags = obj.tags.map((tag) => {
+            if (typeof tag !== 'string') {
+                throw new TypeError('CogitPushContext tags must all be strings');
+            }
+            return tag;
+        });
+        return new CogitPushContext({
+            content: obj.content,
+            operation: obj.operation,
+            path: obj.path,
+            tags,
+            title: obj.title,
+        });
+    }
+    /**
+     * Converts the CogitPushContext instance to a JSON object for the API.
+     * @returns A JSON object for API serialization
+     */
+    toJson() {
+        return {
+            content: this.content,
+            operation: this.operation,
+            path: this.path,
+            tags: [...this.tags],
+            title: this.title,
+        };
+    }
+}

package/dist/core/domain/entities/cogit-push-response.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Parameters for creating a CogitPushResponse instance.
+ */
+export type CogitPushResponseParams = {
+    message: string;
+    success: boolean;
+};
+export declare class CogitPushResponse {
+    readonly message: string;
+    readonly success: boolean;
+    constructor(params: CogitPushResponseParams);
+    /**
+     * Creates a CogitPushResponse instance from a JSON object.
+     * Handles snake_case API response format.
+     * @param json JSON object representing the response
+     * @returns An instance of CogitPushResponse
+     * @throws TypeError if required fields are missing or have invalid types
+     */
+    static fromJson(json: unknown): CogitPushResponse;
+}

package/dist/core/domain/entities/cogit-push-response.js

@@ -0,0 +1,31 @@
+export class CogitPushResponse {
+    message;
+    success;
+    constructor(params) {
+        this.message = params.message;
+        this.success = params.success;
+    }
+    /**
+     * Creates a CogitPushResponse instance from a JSON object.
+     * Handles snake_case API response format.
+     * @param json JSON object representing the response
+     * @returns An instance of CogitPushResponse
+     * @throws TypeError if required fields are missing or have invalid types
+     */
+    static fromJson(json) {
+        if (!json || typeof json !== 'object') {
+            throw new TypeError('CogitPushResponse JSON must be an object');
+        }
+        const obj = json;
+        if (typeof obj.success !== 'boolean') {
+            throw new TypeError('CogitPushResponse JSON must have a boolean success field');
+        }
+        if (typeof obj.message !== 'string') {
+            throw new TypeError('CogitPushResponse JSON must have a string message field');
+        }
+        return new CogitPushResponse({
+            message: obj.message,
+            success: obj.success,
+        });
+    }
+}

package/dist/core/domain/entities/cogit-snapshot-author.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Parameters for creating a CogitSnapshotAuthor instance.
+ */
+export type CogitSnapshotAuthorParams = {
+    email: string;
+    name: string;
+    when: string;
+};
+/**
+ * Represents the author information in a CoGit snapshot.
+ */
+export declare class CogitSnapshotAuthor {
+    readonly email: string;
+    readonly name: string;
+    readonly when: Date;
+    constructor(params: CogitSnapshotAuthorParams);
+    /**
+     * Creates a CogitSnapshotAuthor instance from a JSON object.
+     * @param json JSON object representing the author
+     * @returns An instance of CogitSnapshotAuthor
+     * @throws TypeError if required fields are missing or have invalid types
+     */
+    static fromJson(json: unknown): CogitSnapshotAuthor;
+}

package/dist/core/domain/entities/cogit-snapshot-author.js

@@ -0,0 +1,39 @@
+/**
+ * Represents the author information in a CoGit snapshot.
+ */
+export class CogitSnapshotAuthor {
+    email;
+    name;
+    when;
+    constructor(params) {
+        this.email = params.email;
+        this.name = params.name;
+        this.when = new Date(params.when);
+    }
+    /**
+     * Creates a CogitSnapshotAuthor instance from a JSON object.
+     * @param json JSON object representing the author
+     * @returns An instance of CogitSnapshotAuthor
+     * @throws TypeError if required fields are missing or have invalid types
+     */
+    static fromJson(json) {
+        if (!json || typeof json !== 'object') {
+            throw new TypeError('CogitSnapshotAuthor JSON must be an object');
+        }
+        const obj = json;
+        if (typeof obj.email !== 'string') {
+            throw new TypeError('CogitSnapshotAuthor JSON must have a string email field');
+        }
+        if (typeof obj.name !== 'string') {
+            throw new TypeError('CogitSnapshotAuthor JSON must have a string name field');
+        }
+        if (typeof obj.when !== 'string') {
+            throw new TypeError('CogitSnapshotAuthor JSON must have a string when field');
+        }
+        return new CogitSnapshotAuthor({
+            email: obj.email,
+            name: obj.name,
+            when: obj.when,
+        });
+    }
+}

package/dist/core/domain/entities/cogit-snapshot-file.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Parameters for creating a CogitSnapshotFile instance.
+ */
+export type CogitSnapshotFileParams = {
+    content: string;
+    mode: string;
+    path: string;
+    sha: string;
+    size: number;
+};
+/**
+ * Represents a single file in a CoGit snapshot.
+ * Content is base64-encoded.
+ */
+export declare class CogitSnapshotFile {
+    readonly content: string;
+    readonly mode: string;
+    readonly path: string;
+    readonly sha: string;
+    readonly size: number;
+    constructor(params: CogitSnapshotFileParams);
+    /**
+     * Creates a CogitSnapshotFile instance from a JSON object.
+     * @param json JSON object representing the file
+     * @returns An instance of CogitSnapshotFile
+     * @throws TypeError if required fields are missing or have invalid types
+     */
+    static fromJson(json: unknown): CogitSnapshotFile;
+    /**
+     * Decodes the base64 content to a UTF-8 string.
+     * @returns Decoded file content
+     */
+    decodeContent(): string;
+}

package/dist/core/domain/entities/cogit-snapshot-file.js

@@ -0,0 +1,59 @@
+/**
+ * Represents a single file in a CoGit snapshot.
+ * Content is base64-encoded.
+ */
+export class CogitSnapshotFile {
+    content;
+    mode;
+    path;
+    sha;
+    size;
+    constructor(params) {
+        this.content = params.content;
+        this.mode = params.mode;
+        this.path = params.path;
+        this.sha = params.sha;
+        this.size = params.size;
+    }
+    /**
+     * Creates a CogitSnapshotFile instance from a JSON object.
+     * @param json JSON object representing the file
+     * @returns An instance of CogitSnapshotFile
+     * @throws TypeError if required fields are missing or have invalid types
+     */
+    static fromJson(json) {
+        if (!json || typeof json !== 'object') {
+            throw new TypeError('CogitSnapshotFile JSON must be an object');
+        }
+        const obj = json;
+        if (typeof obj.content !== 'string') {
+            throw new TypeError('CogitSnapshotFile JSON must have a string content field');
+        }
+        if (typeof obj.mode !== 'string') {
+            throw new TypeError('CogitSnapshotFile JSON must have a string mode field');
+        }
+        if (typeof obj.path !== 'string') {
+            throw new TypeError('CogitSnapshotFile JSON must have a string path field');
+        }
+        if (typeof obj.sha !== 'string') {
+            throw new TypeError('CogitSnapshotFile JSON must have a string sha field');
+        }
+        if (typeof obj.size !== 'number') {
+            throw new TypeError('CogitSnapshotFile JSON must have a number size field');
+        }
+        return new CogitSnapshotFile({
+            content: obj.content,
+            mode: obj.mode,
+            path: obj.path,
+            sha: obj.sha,
+            size: obj.size,
+        });
+    }
+    /**
+     * Decodes the base64 content to a UTF-8 string.
+     * @returns Decoded file content
+     */
+    decodeContent() {
+        return Buffer.from(this.content, 'base64').toString('utf8');
+    }
+}

package/dist/core/domain/entities/cogit-snapshot.d.ts

@@ -0,0 +1,31 @@
+import { CogitSnapshotAuthor } from './cogit-snapshot-author.js';
+import { CogitSnapshotFile } from './cogit-snapshot-file.js';
+/**
+ * Parameters for creating a CogitSnapshot instance.
+ */
+export type CogitSnapshotParams = {
+    author: CogitSnapshotAuthor;
+    branch: string;
+    commitSha: string;
+    files: CogitSnapshotFile[];
+    message: string;
+};
+/**
+ * Represents a complete CoGit snapshot response.
+ */
+export declare class CogitSnapshot {
+    readonly author: CogitSnapshotAuthor;
+    readonly branch: string;
+    readonly commitSha: string;
+    readonly files: readonly CogitSnapshotFile[];
+    readonly message: string;
+    constructor(params: CogitSnapshotParams);
+    /**
+     * Creates a CogitSnapshot instance from a JSON object.
+     * Handles snake_case API response format (commit_sha -> commitSha).
+     * @param json JSON object representing the snapshot
+     * @returns An instance of CogitSnapshot
+     * @throws TypeError if required fields are missing or have invalid types
+     */
+    static fromJson(json: unknown): CogitSnapshot;
+}

package/dist/core/domain/entities/cogit-snapshot.js

@@ -0,0 +1,58 @@
+import { CogitSnapshotAuthor } from './cogit-snapshot-author.js';
+import { CogitSnapshotFile } from './cogit-snapshot-file.js';
+/**
+ * Represents a complete CoGit snapshot response.
+ */
+export class CogitSnapshot {
+    author;
+    branch;
+    commitSha;
+    files;
+    message;
+    constructor(params) {
+        this.author = params.author;
+        this.branch = params.branch;
+        this.commitSha = params.commitSha;
+        // Defensive copy to prevent external mutation
+        this.files = [...params.files];
+        this.message = params.message;
+    }
+    /**
+     * Creates a CogitSnapshot instance from a JSON object.
+     * Handles snake_case API response format (commit_sha -> commitSha).
+     * @param json JSON object representing the snapshot
+     * @returns An instance of CogitSnapshot
+     * @throws TypeError if required fields are missing or have invalid types
+     */
+    static fromJson(json) {
+        if (!json || typeof json !== 'object') {
+            throw new TypeError('CogitSnapshot JSON must be an object');
+        }
+        const obj = json;
+        if (typeof obj.branch !== 'string') {
+            throw new TypeError('CogitSnapshot JSON must have a string branch field');
+        }
+        // Handle snake_case from API
+        if (typeof obj.commit_sha !== 'string') {
+            throw new TypeError('CogitSnapshot JSON must have a string commit_sha field');
+        }
+        if (typeof obj.message !== 'string') {
+            throw new TypeError('CogitSnapshot JSON must have a string message field');
+        }
+        if (!Array.isArray(obj.files)) {
+            throw new TypeError('CogitSnapshot JSON must have a files array');
+        }
+        if (!obj.author || typeof obj.author !== 'object') {
+            throw new TypeError('CogitSnapshot JSON must have an author object');
+        }
+        const files = obj.files.map((file) => CogitSnapshotFile.fromJson(file));
+        const author = CogitSnapshotAuthor.fromJson(obj.author);
+        return new CogitSnapshot({
+            author,
+            branch: obj.branch,
+            commitSha: obj.commit_sha,
+            files,
+            message: obj.message,
+        });
+    }
+}