byterover-cli 2.6.0 → 3.0.1

package/dist/server/core/interfaces/services/i-git-service.d.ts

@@ -0,0 +1,234 @@
+export type BaseGitParams = {
+    directory: string;
+};
+export type GitStatusFile = {
+    path: string;
+    staged: boolean;
+    status: 'added' | 'deleted' | 'modified' | 'untracked';
+};
+export type GitStatus = {
+    /** Only contains files with changes. Empty when the working tree is clean. */
+    files: GitStatusFile[];
+    isClean: boolean;
+};
+export type GitCommit = {
+    author: {
+        email: string;
+        name: string;
+    };
+    message: string;
+    sha: string;
+    timestamp: Date;
+};
+export type GitBranch = {
+    isCurrent: boolean;
+    isRemote: boolean;
+    name: string;
+};
+export type GitConflict = {
+    path: string;
+    type: 'both_added' | 'both_modified' | 'deleted_modified';
+};
+export type GitRemote = {
+    remote: string;
+    url: string;
+};
+export type PushResult = {
+    alreadyUpToDate?: boolean;
+    success: true;
+} | {
+    message?: string;
+    reason: 'non_fast_forward';
+    success: false;
+};
+export type PullResult = {
+    alreadyUpToDate?: boolean;
+    success: true;
+} | {
+    conflicts: GitConflict[];
+    success: false;
+};
+export type MergeResult = {
+    alreadyUpToDate?: boolean;
+    success: true;
+} | {
+    conflicts: GitConflict[];
+    success: false;
+};
+export type TrackingBranch = {
+    remote: string;
+    remoteBranch: string;
+};
+export type AheadBehind = {
+    ahead: number;
+    behind: number;
+};
+export type InitGitParams = BaseGitParams & {
+    defaultBranch?: string;
+};
+export type AddGitParams = BaseGitParams & {
+    filePaths: string[];
+};
+export type CommitGitParams = BaseGitParams & {
+    author?: {
+        email: string;
+        name: string;
+    };
+    message: string;
+};
+export type LogGitParams = BaseGitParams & {
+    depth?: number;
+    ref?: string;
+};
+export type PushGitParams = BaseGitParams & {
+    branch?: string;
+    remote?: string;
+};
+export type PullGitParams = BaseGitParams & {
+    allowUnrelatedHistories?: boolean;
+    author?: {
+        email: string;
+        name: string;
+    };
+    branch?: string;
+    remote?: string;
+};
+export type FetchGitParams = BaseGitParams & {
+    ref?: string;
+    remote?: string;
+};
+export type AbortMergeGitParams = BaseGitParams;
+export type MergeGitParams = BaseGitParams & {
+    allowUnrelatedHistories?: boolean;
+    author?: {
+        email: string;
+        name: string;
+    };
+    branch: string;
+    message?: string;
+};
+export type CreateBranchGitParams = BaseGitParams & {
+    branch: string;
+    checkout?: boolean;
+};
+export type DeleteBranchGitParams = BaseGitParams & {
+    branch: string;
+};
+export type ListBranchesGitParams = BaseGitParams & {
+    remote?: string;
+};
+export type CheckoutGitParams = BaseGitParams & {
+    force?: boolean;
+    ref: string;
+};
+export type AddRemoteGitParams = BaseGitParams & {
+    remote: string;
+    url: string;
+};
+export type RemoveRemoteGitParams = BaseGitParams & {
+    remote: string;
+};
+export type GetRemoteUrlGitParams = BaseGitParams & {
+    remote: string;
+};
+export type GetTrackingBranchParams = BaseGitParams & {
+    branch: string;
+};
+export type SetTrackingBranchParams = BaseGitParams & {
+    branch: string;
+    remote: string;
+    remoteBranch: string;
+};
+export type GetAheadBehindParams = BaseGitParams & {
+    localRef: string;
+    remoteRef: string;
+};
+export type ResetMode = 'hard' | 'mixed' | 'soft';
+export type ResetGitParams = BaseGitParams & {
+    filePaths?: string[];
+    mode?: ResetMode;
+    ref?: string;
+};
+export type ResetResult = {
+    filesChanged: number;
+    headSha: string;
+};
+export type CloneGitParams = BaseGitParams & {
+    onProgress?: (progress: {
+        loaded: number;
+        phase: string;
+        total?: number;
+    }) => void;
+    url: string;
+};
+export interface IGitService {
+    abortMerge(params: AbortMergeGitParams): Promise<void>;
+    add(params: AddGitParams): Promise<void>;
+    addRemote(params: AddRemoteGitParams): Promise<void>;
+    checkout(params: CheckoutGitParams): Promise<void>;
+    clone(params: CloneGitParams): Promise<void>;
+    commit(params: CommitGitParams): Promise<GitCommit>;
+    createBranch(params: CreateBranchGitParams): Promise<void>;
+    deleteBranch(params: DeleteBranchGitParams): Promise<void>;
+    fetch(params: FetchGitParams): Promise<void>;
+    /** Returns how many commits the local ref is ahead/behind relative to the remote ref. */
+    getAheadBehind(params: GetAheadBehindParams): Promise<AheadBehind>;
+    /**
+     * Returns conflicts currently present in the working tree.
+     * Detects all three conflict types (both_modified, both_added, deleted_modified)
+     * by inspecting the git status matrix.
+     *
+     * Returns an empty array when no merge is in progress (MERGE_HEAD absent).
+     *
+     * Use this to inspect conflict state when the original `merge()` / `pull()` result is
+     * no longer available — e.g. after a process restart or when refreshing a conflict UI.
+     */
+    getConflicts(params: BaseGitParams): Promise<GitConflict[]>;
+    /** Returns the current branch name, or `undefined` when in detached HEAD state. */
+    getCurrentBranch(params: BaseGitParams): Promise<string | undefined>;
+    /**
+     * Scans tracked files for git conflict markers (`<<<<<<<`, `=======`, `>>>>>>>`).
+     * Unlike `getConflicts()`, this works regardless of merge state — it detects
+     * leftover markers even after a merge is completed or aborted.
+     */
+    getFilesWithConflictMarkers(params: BaseGitParams): Promise<string[]>;
+    getRemoteUrl(params: GetRemoteUrlGitParams): Promise<string | undefined>;
+    /** Returns the upstream tracking branch config, or `undefined` if not configured. */
+    getTrackingBranch(params: GetTrackingBranchParams): Promise<TrackingBranch | undefined>;
+    init(params: InitGitParams): Promise<void>;
+    /** Returns true if `ancestor` commit is reachable from `commit`. */
+    isAncestor(params: BaseGitParams & {
+        ancestor: string;
+        commit: string;
+    }): Promise<boolean>;
+    /** Returns true if the repository is freshly initialized with no commits, remotes, branches, tags, or untracked files. */
+    isEmptyRepository(params: BaseGitParams): Promise<boolean>;
+    /** Returns true if a git repository (.git directory) exists at the given directory. */
+    isInitialized(params: BaseGitParams): Promise<boolean>;
+    /** Lists local branches. When `remote` is specified, also includes remote-tracking branches. */
+    listBranches(params: ListBranchesGitParams): Promise<GitBranch[]>;
+    listRemotes(params: BaseGitParams): Promise<GitRemote[]>;
+    log(params: LogGitParams): Promise<GitCommit[]>;
+    merge(params: MergeGitParams): Promise<MergeResult>;
+    pull(params: PullGitParams): Promise<PullResult>;
+    /**
+     * Pushes local commits to the remote.
+     * Returns `{success: false, reason: 'non_fast_forward'}` when the remote has
+     * diverged (recoverable — caller can pull or force-push).
+     * Throws for unrecoverable failures (network error, auth failure, remote not found).
+     */
+    push(params: PushGitParams): Promise<PushResult>;
+    removeRemote(params: RemoveRemoteGitParams): Promise<void>;
+    /**
+     * Resets the index and/or HEAD.
+     * - filePaths provided: unstages specific files (always mixed, ignores mode)
+     * - mode=mixed (default): resets index to ref. If ref is HEAD, unstages all.
+     *   If ref is a commit (e.g. HEAD~1), moves HEAD back and unstages.
+     * - mode=soft: moves HEAD to ref, keeps index and working tree intact
+     * - mode=hard: moves HEAD to ref, resets index and working tree
+     */
+    reset(params: ResetGitParams): Promise<ResetResult>;
+    /** Writes upstream tracking config: `branch.<name>.remote` and `branch.<name>.merge`. */
+    setTrackingBranch(params: SetTrackingBranchParams): Promise<void>;
+    status(params: BaseGitParams): Promise<GitStatus>;
+}

package/dist/server/core/interfaces/services/i-git-service.js

@@ -0,0 +1 @@
+export {};

package/dist/server/core/interfaces/storage/i-curate-log-store.d.ts

@@ -1,6 +1,11 @@
 import type { CurateLogEntry } from '../../domain/entities/curate-log-entry.js';
 export type CurateLogStatus = 'cancelled' | 'completed' | 'error' | 'processing';
 export interface ICurateLogStore {
+    /** Batch-update reviewStatus for multiple operations within a single log entry. Reads once, writes once. */
+    batchUpdateOperationReviewStatus(logId: string, updates: Array<{
+        operationIndex: number;
+        reviewStatus: 'approved' | 'rejected';
+    }>): Promise<boolean>;
     /** Retrieve an entry by ID. Returns null if not found or if the file is corrupt. */
     getById(id: string): Promise<CurateLogEntry | null>;
     /** Generate the next monotonic log entry ID. */

package/dist/server/core/interfaces/storage/i-review-backup-store.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Store for pre-curate file content backups.
+ *
+ * When a curate operation modifies a file that was previously pushed (exists in snapshot),
+ * the original content is backed up here. The review UI uses these backups to compute diffs
+ * (snapshot version → current version). Backups are cleared after a successful push.
+ */
+export interface IReviewBackupStore {
+    /** Remove all backups. Called after a successful push creates a new snapshot. */
+    clear(): Promise<void>;
+    /** Delete the backup for a given relative path. No-op if no backup exists. */
+    delete(relativePath: string): Promise<void>;
+    /** Check if a backup exists for the given relative path. */
+    has(relativePath: string): Promise<boolean>;
+    /** Read the backed-up content for a relative path. Returns null if no backup exists. */
+    read(relativePath: string): Promise<null | string>;
+    /** Save a backup of file content. No-op if a backup already exists (first-write wins). */
+    save(relativePath: string, content: string): Promise<void>;
+}

package/dist/server/core/interfaces/storage/i-review-backup-store.js

@@ -0,0 +1 @@
+export {};

package/dist/server/core/interfaces/vc/i-vc-git-config-store.d.ts

@@ -0,0 +1,8 @@
+export interface IVcGitConfig {
+    email?: string;
+    name?: string;
+}
+export interface IVcGitConfigStore {
+    get(projectPath: string): Promise<IVcGitConfig | undefined>;
+    set(projectPath: string, config: IVcGitConfig): Promise<void>;
+}

package/dist/server/core/interfaces/vc/i-vc-git-config-store.js

@@ -0,0 +1 @@
+export {};

package/dist/server/infra/config/auto-init.d.ts

@@ -1,9 +1,7 @@
 import type { IContextTreeService } from '../../core/interfaces/context-tree/i-context-tree-service.js';
-import type { IContextTreeSnapshotService } from '../../core/interfaces/context-tree/i-context-tree-snapshot-service.js';
 import type { IProjectConfigStore } from '../../core/interfaces/storage/i-project-config-store.js';
 export interface AutoInitDeps {
     contextTreeService: IContextTreeService;
-    contextTreeSnapshotService: IContextTreeSnapshotService;
     projectConfigStore: IProjectConfigStore;
 }
 /**

package/dist/server/infra/config/auto-init.js

@@ -14,5 +14,4 @@ export async function ensureProjectInitialized(deps, directory) {
     await deps.projectConfigStore.write(config, directory);
     await syncConfigToXdg(config, cwd);
     await deps.contextTreeService.initialize(directory);
-    await deps.contextTreeSnapshotService.initEmptySnapshot(directory);
 }

package/dist/server/infra/context-tree/file-context-tree-service.d.ts

@@ -11,5 +11,7 @@ export declare class FileContextTreeService implements IContextTreeService {
     constructor(config?: ContextTreeServiceConfig);
     delete(directory?: string): Promise<void>;
     exists(directory?: string): Promise<boolean>;
+    hasGitRepo(directory: string): Promise<boolean>;
     initialize(directory?: string): Promise<string>;
+    resolvePath(directory: string): string;
 }

package/dist/server/infra/context-tree/file-context-tree-service.js

@@ -27,6 +27,16 @@ export class FileContextTreeService {
             return false;
         }
     }
+    async hasGitRepo(directory) {
+        const contextTreeDir = this.resolvePath(directory);
+        try {
+            await access(join(contextTreeDir, '.git'));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     async initialize(directory) {
         const baseDir = directory ?? this.config.baseDirectory ?? process.cwd();
         const brvDir = join(baseDir, BRV_DIR);
@@ -36,4 +46,7 @@ export class FileContextTreeService {
         await mkdir(contextTreeDir, { recursive: true });
         return contextTreeDir;
     }
+    resolvePath(directory) {
+        return join(directory, BRV_DIR, CONTEXT_TREE_DIR);
+    }
 }

package/dist/server/infra/daemon/brv-server.js

@@ -21,16 +21,20 @@
  * 10. Start idle timer + register signal handlers
  */
 import { GlobalInstanceManager } from '@campfirein/brv-transport-client';
+import express from 'express';
 import { fork } from 'node:child_process';
 import { mkdirSync, readdirSync, readFileSync, unlinkSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { AGENT_IDLE_CHECK_INTERVAL_MS, AGENT_IDLE_TIMEOUT_MS, AGENT_POOL_MAX_SIZE, HEARTBEAT_FILE, } from '../../constants.js';
+import { ReviewEvents } from '../../../shared/transport/events/review-events.js';
+import { AGENT_IDLE_CHECK_INTERVAL_MS, AGENT_IDLE_TIMEOUT_MS, AGENT_POOL_MAX_SIZE, BRV_DIR, HEARTBEAT_FILE, } from '../../constants.js';
 import { TransportStateEventNames } from '../../core/domain/transport/schemas.js';
 import { getGlobalDataDir } from '../../utils/global-data-path.js';
+import { getProjectDataDir } from '../../utils/path-utils.js';
 import { crashLog, processLog } from '../../utils/process-logger.js';
 import { ClientManager } from '../client/client-manager.js';
 import { ProjectConfigStore } from '../config/file-config-store.js';
+import { createReviewApiRouter } from '../http/review-api-handler.js';
 import { broadcastToProjectRoom } from '../process/broadcast-utils.js';
 import { CurateLogHandler } from '../process/curate-log-handler.js';
 import { setupFeatureHandlers } from '../process/feature-handlers.js';
@@ -42,7 +46,9 @@ import { clearStaleProviderConfig, resolveProviderConfig } from '../provider/pro
 import { ProjectRouter } from '../routing/project-router.js';
 import { AuthStateStore } from '../state/auth-state-store.js';
 import { ProjectStateLoader } from '../state/project-state-loader.js';
+import { FileCurateLogStore } from '../storage/file-curate-log-store.js';
 import { FileProviderConfigStore } from '../storage/file-provider-config-store.js';
+import { FileReviewBackupStore } from '../storage/file-review-backup-store.js';
 import { createProviderKeychainStore } from '../storage/provider-keychain-store.js';
 import { createTokenStore } from '../storage/token-store.js';
 import { SocketIOTransportServer } from '../transport/socket-io-transport-server.js';
@@ -145,8 +151,14 @@ async function main() {
     let authStateStore;
     let agentPool;
     try {
-        // 4. Start Socket.IO transport server
+        // 4. Start Socket.IO transport server (with Express for HTTP routes)
         transportServer = new SocketIOTransportServer();
+        const app = express();
+        app.use(createReviewApiRouter({
+            curateLogStoreFactory: (projectPath) => new FileCurateLogStore({ baseDir: getProjectDataDir(projectPath) }),
+            reviewBackupStoreFactory: (projectPath) => new FileReviewBackupStore(join(projectPath, BRV_DIR)),
+        }));
+        transportServer.setHttpRequestHandler(app);
         await transportServer.start(port);
         log(`Transport server started on port ${port}`);
         // 5. Start heartbeat writer
@@ -226,7 +238,15 @@ async function main() {
         });
         // Start agent idle timeout policy
         agentIdleTimeoutPolicy.start();
-        const curateLogHandler = new CurateLogHandler();
+        const curateLogHandler = new CurateLogHandler(undefined, (info) => {
+            const encoded = Buffer.from(info.projectPath).toString('base64url');
+            const reviewUrl = `http://127.0.0.1:${port}/review?project=${encoded}`;
+            const payload = { pendingCount: info.pendingCount, reviewUrl, taskId: info.taskId };
+            // Send directly to the task originator (covers CLI clients not in the project room)
+            transportServer.sendTo(info.clientId, ReviewEvents.NOTIFY, payload);
+            // Also broadcast to the project room so TUI and other connected clients are notified
+            broadcastToProjectRoom(projectRegistry, projectRouter, info.projectPath, ReviewEvents.NOTIFY, payload, info.clientId);
+        });
         const transportHandlers = new TransportHandlers({
             agentPool,
             clientManager,

package/dist/server/infra/git/cogit-url.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Build the CoGit Git remote URL for a given team and space.
+ * Format: {baseUrl}/{teamName}/{spaceName}.git
+ */
+export declare function buildCogitRemoteUrl(baseUrl: string, teamName: string, spaceName: string): string;
+/**
+ * Parse a .git URL to extract team and space names.
+ * Expected path: /{teamName}/{spaceName}.git
+ */
+export declare function parseUserFacingUrl(url: string): null | {
+    spaceName: string;
+    teamName: string;
+};
+/**
+ * Validate git branch name (same rules as native git).
+ */
+export declare function isValidBranchName(name: string): boolean;

package/dist/server/infra/git/cogit-url.js

@@ -0,0 +1,39 @@
+/**
+ * Build the CoGit Git remote URL for a given team and space.
+ * Format: {baseUrl}/{teamName}/{spaceName}.git
+ */
+export function buildCogitRemoteUrl(baseUrl, teamName, spaceName) {
+    const base = baseUrl.replace(/\/$/, '');
+    return `${base}/${teamName}/${spaceName}.git`;
+}
+/**
+ * Parse a .git URL to extract team and space names.
+ * Expected path: /{teamName}/{spaceName}.git
+ */
+export function parseUserFacingUrl(url) {
+    try {
+        const parsed = new URL(url);
+        const match = parsed.pathname.match(/^\/([^/]+)\/([^/]+?)\.git$/);
+        if (!match)
+            return null;
+        return { spaceName: match[2], teamName: match[1] };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Validate git branch name (same rules as native git).
+ */
+export function isValidBranchName(name) {
+    if (!name)
+        return false;
+    if (name.startsWith('-') || name.startsWith('.') || name.startsWith('/'))
+        return false;
+    if (name.endsWith('.lock') || name.endsWith('/') || name.endsWith('.'))
+        return false;
+    if (name.includes('//') || name.includes('@{') || name.includes(' '))
+        return false;
+    // eslint-disable-next-line no-control-regex
+    return !/\.\.|[~^:?*[\\\u0000-\u001F\u007F]/.test(name);
+}

package/dist/server/infra/git/git-http-wrapper.d.ts

@@ -0,0 +1,20 @@
+import { request as httpRequest } from 'isomorphic-git/http/node';
+/**
+ * Wraps isomorphic-git's HTTP client to ensure Git Smart HTTP Protocol v1 compliance.
+ *
+ * ByteRover CoGit exhibits two non-standard behaviours:
+ *
+ *  1. git-receive-pack (push): Returns a valid pktline ref advertisement with the
+ *     correct Content-Type, but OMITS the required `# service=git-receive-pack\n`
+ *     preamble. This wrapper injects the missing preamble.
+ *
+ *  2. git-upload-pack (fetch/clone): Always returns a Git Protocol v2 capability
+ *     advertisement, even when the client does not request v2. isomorphic-git uses
+ *     Protocol v1 internally and cannot use a v2 response for its fetch logic.
+ *     This wrapper:
+ *       a. Translates the info/refs v2 response to v1 (ls-refs POST + synthetic refs advertisement)
+ *       b. Intercepts the subsequent pack-data POST and converts it from v1 to v2 fetch command
+ */
+export declare const gitHttpWrapper: {
+    request: typeof httpRequest;
+};