byterover-cli 2.5.2 → 3.0.0

package/dist/server/infra/transport/handlers/review-handler.js

@@ -0,0 +1,162 @@
+import { mkdir, unlink, writeFile } from 'node:fs/promises';
+import { dirname, join, relative } from 'node:path';
+import { ReviewEvents, } from '../../../../shared/transport/events/review-events.js';
+import { BRV_DIR, CONTEXT_TREE_DIR } from '../../../constants.js';
+import { resolveRequiredProjectPath } from './handler-types.js';
+// ── Helpers ──────────────────────────────────────────────────────────────────
+async function writeFileWithDirs(absolutePath, content) {
+    await mkdir(dirname(absolutePath), { recursive: true });
+    await writeFile(absolutePath, content, 'utf8');
+}
+// ── Handler ──────────────────────────────────────────────────────────────────
+/**
+ * Handles review:decideTask — approves or rejects all pending review operations
+ * for a given task ID in a single transport request.
+ *
+ * Mirrors the per-file logic in review-api-handler.ts but operates at task scope.
+ */
+export class ReviewHandler {
+    curateLogStoreFactory;
+    onResolved;
+    resolveProjectPath;
+    reviewBackupStoreFactory;
+    transport;
+    constructor(deps) {
+        this.curateLogStoreFactory = deps.curateLogStoreFactory;
+        this.onResolved = deps.onResolved;
+        this.resolveProjectPath = deps.resolveProjectPath;
+        this.reviewBackupStoreFactory = deps.reviewBackupStoreFactory;
+        this.transport = deps.transport;
+    }
+    setup() {
+        this.transport.onRequest(ReviewEvents.DECIDE_TASK, (data, clientId) => this.handleDecideTask(data, clientId));
+        this.transport.onRequest(ReviewEvents.PENDING, (_data, clientId) => this.handlePending(clientId));
+    }
+    async handleDecideTask({ decision, filePaths: filterPaths, taskId }, clientId) {
+        const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        const contextTreeDir = join(projectPath, BRV_DIR, CONTEXT_TREE_DIR);
+        const store = this.curateLogStoreFactory(projectPath);
+        const backupStore = this.reviewBackupStoreFactory(projectPath);
+        const entries = await store.list();
+        // Collect pending ops grouped by relative file path for this taskId
+        const pendingByPath = new Map();
+        for (const entry of entries) {
+            if (entry.taskId !== taskId)
+                continue;
+            for (let i = 0; i < entry.operations.length; i++) {
+                const op = entry.operations[i];
+                if (op.reviewStatus !== 'pending' || !op.filePath)
+                    continue;
+                const rel = relative(contextTreeDir, op.filePath);
+                if (rel.startsWith('..'))
+                    continue;
+                let ops = pendingByPath.get(rel);
+                if (!ops) {
+                    ops = [];
+                    pendingByPath.set(rel, ops);
+                }
+                ops.push({ additionalFilePaths: op.additionalFilePaths, logId: entry.id, operationIndex: i });
+            }
+        }
+        // If filePaths filter is provided, only process those files
+        if (filterPaths?.length) {
+            const filterSet = new Set(filterPaths);
+            const keysToDelete = [...pendingByPath.keys()].filter((key) => !filterSet.has(key));
+            for (const key of keysToDelete)
+                pendingByPath.delete(key);
+        }
+        // Apply decision for each affected file in parallel.
+        // allSettled so a single file failure does not block log updates for files that succeeded.
+        const settled = await Promise.allSettled([...pendingByPath.entries()].map(async ([relPath, ops]) => {
+            let reverted = false;
+            const allAdditionalPaths = [...new Set(ops.flatMap((o) => o.additionalFilePaths ?? []))];
+            if (decision === 'rejected') {
+                const absolutePath = join(contextTreeDir, relPath);
+                const backupContent = await backupStore.read(relPath);
+                // null backup = ADD operation (new file) → remove it; existing backup → restore
+                await (backupContent === null
+                    ? unlink(absolutePath).catch(() => { })
+                    : writeFileWithDirs(absolutePath, backupContent));
+                // Restore additional paths (MERGE source, folder DELETE contents).
+                // Best-effort: partial failures must not block the log update below.
+                await Promise.allSettled(allAdditionalPaths.map(async (absPath) => {
+                    const rel = relative(contextTreeDir, absPath);
+                    const content = await backupStore.read(rel);
+                    if (content !== null)
+                        await writeFileWithDirs(absPath, content);
+                }));
+                reverted = true;
+            }
+            // Clear backups for both approve and reject (current state becomes new baseline)
+            await backupStore.delete(relPath);
+            await Promise.allSettled(allAdditionalPaths.map((absPath) => backupStore.delete(relative(contextTreeDir, absPath))));
+            return { ops, path: relPath, reverted };
+        }));
+        // Only update log entries for files that were successfully processed.
+        // Files that failed remain pending and can be retried.
+        const fileResults = settled
+            .filter((r) => r.status === 'fulfilled')
+            .map((r) => r.value);
+        // Batch-update review status grouped by logId (one read+write per entry file)
+        const byLogId = new Map();
+        for (const { ops } of fileResults) {
+            for (const { logId, operationIndex } of ops) {
+                let batch = byLogId.get(logId);
+                if (!batch) {
+                    batch = [];
+                    byLogId.set(logId, batch);
+                }
+                batch.push({ operationIndex, reviewStatus: decision });
+            }
+        }
+        await Promise.all([...byLogId.entries()].map(([logId, updates]) => store.batchUpdateOperationReviewStatus(logId, updates)));
+        try {
+            this.onResolved?.({ projectPath, taskId });
+        }
+        catch {
+            // Best-effort notification — never block the response
+        }
+        const totalCount = fileResults.reduce((sum, { ops }) => sum + ops.length, 0);
+        return { files: fileResults.map(({ path, reverted }) => ({ path, reverted })), totalCount };
+    }
+    async handlePending(clientId) {
+        const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        const contextTreeDir = join(projectPath, BRV_DIR, CONTEXT_TREE_DIR);
+        const store = this.curateLogStoreFactory(projectPath);
+        const entries = await store.list({ status: ['completed'] });
+        const taskMap = new Map();
+        for (const entry of entries) {
+            for (const op of entry.operations) {
+                // Skip failed ops (e.g. validation errors) — they were never applied to disk
+                if (op.reviewStatus !== 'pending' || op.status === 'failed')
+                    continue;
+                let ops = taskMap.get(entry.taskId);
+                if (!ops) {
+                    ops = [];
+                    taskMap.set(entry.taskId, ops);
+                }
+                const pendingOp = { path: op.path, type: op.type };
+                if (op.filePath) {
+                    const rel = relative(contextTreeDir, op.filePath);
+                    if (!rel.startsWith('..'))
+                        pendingOp.filePath = rel;
+                }
+                if (op.impact)
+                    pendingOp.impact = op.impact;
+                if (op.reason)
+                    pendingOp.reason = op.reason;
+                if (op.previousSummary)
+                    pendingOp.previousSummary = op.previousSummary;
+                if (op.summary)
+                    pendingOp.summary = op.summary;
+                ops.push(pendingOp);
+            }
+        }
+        const tasks = [...taskMap.entries()].map(([taskId, operations]) => ({
+            operations,
+            taskId,
+        }));
+        const pendingCount = tasks.reduce((sum, t) => sum + t.operations.length, 0);
+        return { pendingCount, tasks };
+    }
+}

package/dist/server/infra/transport/handlers/space-handler.d.ts

@@ -1,5 +1,6 @@
 import type { ITokenStore } from '../../../core/interfaces/auth/i-token-store.js';
 import type { IContextTreeMerger } from '../../../core/interfaces/context-tree/i-context-tree-merger.js';
+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 { IContextTreeWriterService } from '../../../core/interfaces/context-tree/i-context-tree-writer-service.js';
 import type { ICogitPullService } from '../../../core/interfaces/services/i-cogit-pull-service.js';
@@ -12,6 +13,7 @@ export interface SpaceHandlerDeps {
     broadcastToProject: ProjectBroadcaster;
     cogitPullService: ICogitPullService;
     contextTreeMerger: IContextTreeMerger;
+    contextTreeService: IContextTreeService;
     contextTreeSnapshotService: IContextTreeSnapshotService;
     contextTreeWriterService: IContextTreeWriterService;
     projectConfigStore: IProjectConfigStore;
@@ -29,6 +31,7 @@ export declare class SpaceHandler {
     private readonly broadcastToProject;
     private readonly cogitPullService;
     private readonly contextTreeMerger;
+    private readonly contextTreeService;
     private readonly contextTreeSnapshotService;
     private readonly contextTreeWriterService;
     private readonly projectConfigStore;

package/dist/server/infra/transport/handlers/space-handler.js

@@ -3,7 +3,7 @@ import { SpaceEvents, } from '../../../../shared/transport/events/space-events.j
 import { BRV_DIR, CONTEXT_TREE_CONFLICT_DIR, DEFAULT_BRANCH } from '../../../constants.js';
 import { LocalChangesExistError, NotAuthenticatedError, ProjectNotInitError, SpaceNotFoundError, } from '../../../core/domain/errors/task-error.js';
 import { syncConfigToXdg } from '../../../utils/config-xdg-sync.js';
-import { hasAnyChanges, resolveRequiredProjectPath, } from './handler-types.js';
+import { guardAgainstGitVc, hasAnyChanges, resolveRequiredProjectPath, } from './handler-types.js';
 /**
  * Handles space:* events.
  * Business logic for space listing and switching — no terminal/UI calls.
@@ -12,6 +12,7 @@ export class SpaceHandler {
     broadcastToProject;
     cogitPullService;
     contextTreeMerger;
+    contextTreeService;
     contextTreeSnapshotService;
     contextTreeWriterService;
     projectConfigStore;
@@ -24,6 +25,7 @@ export class SpaceHandler {
         this.broadcastToProject = deps.broadcastToProject;
         this.cogitPullService = deps.cogitPullService;
         this.contextTreeMerger = deps.contextTreeMerger;
+        this.contextTreeService = deps.contextTreeService;
         this.contextTreeSnapshotService = deps.contextTreeSnapshotService;
         this.contextTreeWriterService = deps.contextTreeWriterService;
         this.projectConfigStore = deps.projectConfigStore;
@@ -66,6 +68,7 @@ export class SpaceHandler {
     }
     async handleSwitch(data, clientId) {
         const projectPath = resolveRequiredProjectPath(this.resolveProjectPath, clientId);
+        await guardAgainstGitVc({ contextTreeService: this.contextTreeService, projectPath });
         const token = await this.tokenStore.load();
         if (!token || !token.isValid()) {
             throw new NotAuthenticatedError();

package/dist/server/infra/transport/handlers/status-handler.d.ts

@@ -1,12 +1,16 @@
 import type { ITokenStore } from '../../../core/interfaces/auth/i-token-store.js';
 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 { ICurateLogStore } from '../../../core/interfaces/storage/i-curate-log-store.js';
 import type { IProjectConfigStore } from '../../../core/interfaces/storage/i-project-config-store.js';
 import type { ITransportServer } from '../../../core/interfaces/transport/i-transport-server.js';
 import { type ProjectPathResolver } from './handler-types.js';
+/** Factory that creates a curate log store scoped to a project directory. */
+export type CurateLogStoreFactory = (projectPath: string) => ICurateLogStore;
 export interface StatusHandlerDeps {
     contextTreeService: IContextTreeService;
     contextTreeSnapshotService: IContextTreeSnapshotService;
+    curateLogStoreFactory: CurateLogStoreFactory;
     projectConfigStore: IProjectConfigStore;
     resolveProjectPath: ProjectPathResolver;
     tokenStore: ITokenStore;
@@ -19,6 +23,7 @@ export interface StatusHandlerDeps {
 export declare class StatusHandler {
     private readonly contextTreeService;
     private readonly contextTreeSnapshotService;
+    private readonly curateLogStoreFactory;
     private readonly projectConfigStore;
     private readonly resolveProjectPath;
     private readonly tokenStore;

package/dist/server/infra/transport/handlers/status-handler.js

@@ -9,6 +9,7 @@ import { resolveRequiredProjectPath } from './handler-types.js';
 export class StatusHandler {
     contextTreeService;
     contextTreeSnapshotService;
+    curateLogStoreFactory;
     projectConfigStore;
     resolveProjectPath;
     tokenStore;
@@ -16,6 +17,7 @@ export class StatusHandler {
     constructor(deps) {
         this.contextTreeService = deps.contextTreeService;
         this.contextTreeSnapshotService = deps.contextTreeSnapshotService;
+        this.curateLogStoreFactory = deps.curateLogStoreFactory;
         this.projectConfigStore = deps.projectConfigStore;
         this.resolveProjectPath = deps.resolveProjectPath;
         this.tokenStore = deps.tokenStore;
@@ -67,24 +69,30 @@ export class StatusHandler {
         try {
             const contextTreeExists = await this.contextTreeService.exists(projectPath);
             if (contextTreeExists) {
-                result.contextTreeDir = join(projectPath, BRV_DIR, CONTEXT_TREE_DIR);
-                result.contextTreeRelativeDir = join(BRV_DIR, CONTEXT_TREE_DIR);
-                const hasSnapshot = await this.contextTreeSnapshotService.hasSnapshot(projectPath);
-                if (!hasSnapshot) {
-                    await this.contextTreeSnapshotService.initEmptySnapshot(projectPath);
-                }
-                const changes = await this.contextTreeSnapshotService.getChanges(projectPath);
-                const hasChanges = changes.added.length > 0 || changes.modified.length > 0 || changes.deleted.length > 0;
-                if (hasChanges) {
-                    result.contextTreeStatus = 'has_changes';
-                    result.contextTreeChanges = {
-                        added: changes.added,
-                        deleted: changes.deleted,
-                        modified: changes.modified,
-                    };
+                const hasGitVc = await this.contextTreeService.hasGitRepo(projectPath);
+                if (hasGitVc) {
+                    result.contextTreeStatus = 'git_vc';
                 }
                 else {
-                    result.contextTreeStatus = 'no_changes';
+                    result.contextTreeDir = join(projectPath, BRV_DIR, CONTEXT_TREE_DIR);
+                    result.contextTreeRelativeDir = join(BRV_DIR, CONTEXT_TREE_DIR);
+                    const hasSnapshot = await this.contextTreeSnapshotService.hasSnapshot(projectPath);
+                    if (!hasSnapshot) {
+                        await this.contextTreeSnapshotService.initEmptySnapshot(projectPath);
+                    }
+                    const changes = await this.contextTreeSnapshotService.getChanges(projectPath);
+                    const hasChanges = changes.added.length > 0 || changes.modified.length > 0 || changes.deleted.length > 0;
+                    if (hasChanges) {
+                        result.contextTreeStatus = 'has_changes';
+                        result.contextTreeChanges = {
+                            added: changes.added,
+                            deleted: changes.deleted,
+                            modified: changes.modified,
+                        };
+                    }
+                    else {
+                        result.contextTreeStatus = 'no_changes';
+                    }
                 }
             }
             else {
@@ -94,6 +102,33 @@ export class StatusHandler {
         catch {
             result.contextTreeStatus = 'unknown';
         }
+        // Pending review count (best-effort)
+        try {
+            const store = this.curateLogStoreFactory(projectPath);
+            const entries = await store.list({ limit: 100, status: ['completed'] });
+            const pendingFiles = new Set();
+            const contextTreeRoot = join(projectPath, BRV_DIR, CONTEXT_TREE_DIR);
+            for (const entry of entries) {
+                for (const op of entry.operations) {
+                    if (op.reviewStatus === 'pending' && op.filePath) {
+                        const prefix = contextTreeRoot + '/';
+                        const relativePath = op.filePath.startsWith(prefix) ? op.filePath.slice(prefix.length) : op.filePath;
+                        pendingFiles.add(relativePath);
+                    }
+                }
+            }
+            if (pendingFiles.size > 0) {
+                result.pendingReviewCount = pendingFiles.size;
+                const port = this.transport.getPort();
+                if (port) {
+                    const encoded = Buffer.from(projectPath).toString('base64url');
+                    result.reviewUrl = `http://127.0.0.1:${port}/review?project=${encoded}`;
+                }
+            }
+        }
+        catch {
+            // Best-effort — if the log is unavailable, skip review info
+        }
         return result;
     }
 }

package/dist/server/infra/transport/handlers/vc-handler.d.ts

@@ -0,0 +1,100 @@
+import type { ITokenStore } from '../../../core/interfaces/auth/i-token-store.js';
+import type { IContextTreeService } from '../../../core/interfaces/context-tree/i-context-tree-service.js';
+import type { IGitService } from '../../../core/interfaces/services/i-git-service.js';
+import type { ISpaceService } from '../../../core/interfaces/services/i-space-service.js';
+import type { ITeamService } from '../../../core/interfaces/services/i-team-service.js';
+import type { IProjectConfigStore } from '../../../core/interfaces/storage/i-project-config-store.js';
+import type { ITransportServer } from '../../../core/interfaces/transport/i-transport-server.js';
+import type { IVcGitConfigStore } from '../../../core/interfaces/vc/i-vc-git-config-store.js';
+import { type ProjectBroadcaster, type ProjectPathResolver } from './handler-types.js';
+export interface IVcHandlerDeps {
+    broadcastToProject: ProjectBroadcaster;
+    contextTreeService: IContextTreeService;
+    gitRemoteBaseUrl: string;
+    gitService: IGitService;
+    projectConfigStore: IProjectConfigStore;
+    resolveProjectPath: ProjectPathResolver;
+    spaceService: ISpaceService;
+    teamService: ITeamService;
+    tokenStore: ITokenStore;
+    transport: ITransportServer;
+    vcGitConfigStore: IVcGitConfigStore;
+    webAppUrl: string;
+}
+/**
+ * Handles vc:* events (Version Control commands).
+ */
+export declare class VcHandler {
+    private readonly broadcastToProject;
+    private readonly contextTreeService;
+    private readonly gitRemoteBaseUrl;
+    private readonly gitService;
+    private readonly projectConfigStore;
+    private readonly resolveProjectPath;
+    private readonly spaceService;
+    private readonly teamService;
+    private readonly tokenStore;
+    private readonly transport;
+    private readonly vcGitConfigStore;
+    private readonly webAppUrl;
+    constructor(deps: IVcHandlerDeps);
+    setup(): void;
+    private buildAuthorHint;
+    private buildNoRemoteMessage;
+    /**
+     * Writes a .gitignore to the context-tree directory only if one does not already exist.
+     */
+    private ensureGitignore;
+    /**
+     * When force is NOT set, checks for uncommitted changes and throws
+     * VcError(UNCOMMITTED_CHANGES) if the working tree is dirty.
+     * When force IS set, skips the check entirely (changes will be discarded).
+     */
+    private guardUncommittedChanges;
+    private handleAdd;
+    private handleBranch;
+    private handleBranchCreate;
+    private handleBranchDelete;
+    private handleBranchList;
+    private handleBranchSetUpstream;
+    private handleCheckout;
+    private handleClone;
+    private handleCommit;
+    private handleConfig;
+    private handleFetch;
+    private handleInit;
+    private handleLog;
+    private handleMerge;
+    private handlePull;
+    private handlePush;
+    private handleRemote;
+    private handleReset;
+    private handleStatus;
+    /**
+     * Resolve clone request data into a clean cogit URL + team/space info.
+     * Accepts either a URL or explicit teamName/spaceName.
+     * Auth is handled by IsomorphicGitService via headers, not URL credentials.
+     */
+    private resolveCloneInput;
+    /**
+     * Resolve a remote URL to a clean cogit URL + team/space info.
+     * Expected format: {domain}/{teamName}/{spaceName}.git
+     * Resolves names to IDs via API; rejects unknown formats.
+     *
+     * Auth is handled by IsomorphicGitService via headers, not URL credentials.
+     */
+    private resolveFullCogitUrl;
+    private resolveLogResult;
+    /**
+     * Resolves pull target branch: explicit → tracking config → error.
+     * Mirrors native git: `git pull` without tracking config errors.
+     */
+    private resolvePullBranch;
+    private resolveTargetBranch;
+    /**
+     * Resolve team/space names to IDs via API, build clean cogit URL.
+     */
+    private resolveTeamSpaceNames;
+    private validateBranchName;
+    private validateRemoteUrlDomain;
+}