byterover-cli 2.5.2 → 3.0.0

package/dist/server/core/domain/errors/transport-error.js

@@ -7,28 +7,6 @@ export class TransportError extends Error {
         this.name = 'TransportError';
     }
 }
-/**
- * Error thrown when connection to server fails.
- */
-export class TransportConnectionError extends TransportError {
-    originalError;
-    url;
-    constructor(url, originalError) {
-        super(`Connection failed to ${url}${originalError ? `: ${originalError.message}` : ''}`);
-        this.name = 'TransportConnectionError';
-        this.url = url;
-        this.originalError = originalError;
-    }
-}
-/**
- * Error thrown when client is not connected to server.
- */
-export class TransportNotConnectedError extends TransportError {
-    constructor(operation = 'operation') {
-        super(`Not connected to server. Cannot perform: ${operation}`);
-        this.name = 'TransportNotConnectedError';
-    }
-}
 /**
  * Error thrown when server is not started.
  */
@@ -84,31 +62,3 @@ export class TransportRequestError extends TransportError {
         this.event = event;
     }
 }
-/**
- * Error thrown when room operations fail.
- */
-export class TransportRoomError extends TransportError {
-    operation;
-    room;
-    constructor(room, operation) {
-        super(`Failed to ${operation} room '${room}'`);
-        this.name = 'TransportRoomError';
-        this.room = room;
-        this.operation = operation;
-    }
-}
-/**
- * Error thrown when room operation times out.
- */
-export class TransportRoomTimeoutError extends TransportError {
-    operation;
-    room;
-    timeoutMs;
-    constructor(room, operation, timeoutMs) {
-        super(`${operation === 'join' ? 'Join' : 'Leave'} room '${room}' timed out after ${timeoutMs}ms`);
-        this.name = 'TransportRoomTimeoutError';
-        this.room = room;
-        this.operation = operation;
-        this.timeoutMs = timeoutMs;
-    }
-}

package/dist/server/core/domain/errors/vc-error.d.ts

@@ -0,0 +1,5 @@
+import type { VcErrorCodeType } from '../../../../shared/transport/events/vc-events.js';
+export declare class VcError extends Error {
+    readonly code: VcErrorCodeType;
+    constructor(message: string, code: VcErrorCodeType);
+}

package/dist/server/core/domain/errors/vc-error.js

@@ -0,0 +1,8 @@
+export class VcError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = 'VcError';
+        this.code = code;
+    }
+}

package/dist/server/core/domain/knowledge/markdown-writer.d.ts

@@ -48,9 +48,11 @@ export interface ContextData {
     name: string;
     narrative?: Narrative;
     rawConcept?: RawConcept;
+    reason?: string;
     relations?: string[];
     scoring?: FrontmatterScoring;
     snippets: string[];
+    summary?: string;
     tags: string[];
 }
 interface Frontmatter {
@@ -61,6 +63,7 @@ interface Frontmatter {
     maturity?: 'core' | 'draft' | 'validated';
     recency?: number;
     related: string[];
+    summary?: string;
     tags: string[];
     title?: string;
     updateCount?: number;
@@ -88,7 +91,7 @@ export declare function parseFrontmatterScoring(content: string): FrontmatterSco
 export declare function updateScoringInContent(content: string, scoring: FrontmatterScoring): string;
 export declare const MarkdownWriter: {
     generateContext(data: ContextData): string;
-    mergeContexts(sourceContent: string, targetContent: string): string;
+    mergeContexts(sourceContent: string, targetContent: string, reason?: string, summary?: string): string;
     parseContent(content: string, name?: string): ContextData;
 };
 export {};

package/dist/server/core/domain/knowledge/markdown-writer.js

@@ -5,12 +5,15 @@ import { normalizeRelationPath, parseRelations } from './relation-parser.js';
  * Generate YAML frontmatter block from context data.
  * Only includes fields that have values.
  */
-function generateFrontmatter(title, relations, tags = [], keywords = [], scoring) {
+function generateFrontmatter(title, relations, tags = [], keywords = [], scoring, summary) {
     const normalizedRelations = (relations || []).map(rel => normalizeRelationPath(rel));
     const fm = {};
     if (title) {
         fm.title = title;
     }
+    if (summary) {
+        fm.summary = summary;
+    }
     fm.tags = tags;
     if (normalizedRelations.length > 0) {
         fm.related = normalizedRelations;
@@ -74,6 +77,9 @@ function parseFrontmatter(content) {
         if (typeof parsed.title === 'string') {
             frontmatter.title = parsed.title;
         }
+        if (typeof parsed.summary === 'string') {
+            frontmatter.summary = parsed.summary;
+        }
         // Scoring fields (backward compatible — absent in old files)
         if (typeof parsed.importance === 'number') {
             frontmatter.importance = parsed.importance;
@@ -333,6 +339,18 @@ function parseFactsSection(content) {
     }
     return facts.length > 0 ? facts : undefined;
 }
+function generateReasonSection(reason) {
+    if (!reason)
+        return '';
+    return `\n## Reason\n${reason}\n`;
+}
+function parseReasonSection(content) {
+    const match = content.match(/##\s*Reason\s*\n([\s\S]*?)(?=\n##\s|\n---\n|$)/i);
+    if (!match)
+        return undefined;
+    const text = match[1].trim();
+    return text || undefined;
+}
 function extractSnippetsFromContent(content) {
     let snippetContent = content;
     // Forgiving regex patterns for section removal
@@ -340,6 +358,10 @@ function extractSnippetsFromContent(content) {
     if (relationsMatch) {
         snippetContent = snippetContent.replace(relationsMatch[0], '').trim();
     }
+    const reasonMatch = snippetContent.match(/##\s*Reason[\s\S]*?(?=\n##\s|\n---\n|$)/i);
+    if (reasonMatch) {
+        snippetContent = snippetContent.replace(reasonMatch[0], '').trim();
+    }
     const rawConceptMatch = snippetContent.match(/##\s*Raw Concept[\s\S]*?(?=\n##\s|\n---\n|$)/i);
     if (rawConceptMatch) {
         snippetContent = snippetContent.replace(rawConceptMatch[0], '').trim();
@@ -518,7 +540,7 @@ export function updateScoringInContent(content, scoring) {
         return content;
     }
     const { body, frontmatter } = parsed;
-    const updatedFrontmatter = generateFrontmatter(frontmatter.title ?? '', frontmatter.related, frontmatter.tags, frontmatter.keywords, scoring);
+    const updatedFrontmatter = generateFrontmatter(frontmatter.title ?? '', frontmatter.related, frontmatter.tags, frontmatter.keywords, scoring, frontmatter.summary);
     return updatedFrontmatter + body;
 }
 function parseContentWithFrontmatter(content) {
@@ -529,6 +551,7 @@ function parseContentWithFrontmatter(content) {
             keywords: parsed.frontmatter.keywords,
             relations: parsed.frontmatter.related,
             scoring: extractScoring(parsed.frontmatter),
+            summary: parsed.frontmatter.summary,
             tags: parsed.frontmatter.tags,
             title: parsed.frontmatter.title,
         };
@@ -545,15 +568,16 @@ export const MarkdownWriter = {
     generateContext(data) {
         const snippets = (data.snippets || []).filter(s => s && s.trim());
         const relations = data.relations || [];
-        const frontmatter = generateFrontmatter(data.name, relations, data.tags, data.keywords, data.scoring);
+        const frontmatter = generateFrontmatter(data.name, relations, data.tags, data.keywords, data.scoring, data.summary);
+        const reasonSection = generateReasonSection(data.reason);
         const rawConceptSection = generateRawConceptSection(data.rawConcept);
         const narrativeSection = generateNarrativeSection(data.narrative);
         const factsSection = generateFactsSection(data.facts);
         const hasSnippets = snippets.length > 0;
         // Build the content parts
         const parts = [];
-        // Add sections (rawConcept, narrative, facts) — relations are now in frontmatter
-        const sectionsContent = `${rawConceptSection}${narrativeSection}${factsSection}`.trim();
+        // Add sections — reason first (WHY), then content sections, relations in frontmatter
+        const sectionsContent = `${reasonSection}${rawConceptSection}${narrativeSection}${factsSection}`.trim();
         if (sectionsContent) {
             parts.push(sectionsContent);
         }
@@ -570,12 +594,14 @@ export const MarkdownWriter = {
         const body = parts.length > 0 ? parts.join('\n\n---\n\n') + '\n' : '';
         return `${frontmatter}${body}`;
     },
-    mergeContexts(sourceContent, targetContent) {
+    mergeContexts(sourceContent, targetContent, reason, summary) {
         const sourceParsed = parseContentWithFrontmatter(sourceContent);
         const targetParsed = parseContentWithFrontmatter(targetContent);
         const mergedRelations = [...new Set([...sourceParsed.relations, ...targetParsed.relations])];
         const mergedTags = [...new Set([...sourceParsed.tags, ...targetParsed.tags])];
         const mergedKeywords = [...new Set([...sourceParsed.keywords, ...targetParsed.keywords])];
+        // reason: explicit override wins, then source (newer), then target (older)
+        const mergedReason = reason ?? parseReasonSection(sourceParsed.body) ?? parseReasonSection(targetParsed.body);
         // Merge scoring metadata (FinMem-inspired lifecycle)
         const defaultScoring = { importance: 50, maturity: 'draft', recency: 1 };
         let mergedScoringData;
@@ -609,23 +635,27 @@ export const MarkdownWriter = {
             name: sourceParsed.title || targetParsed.title || '',
             narrative: mergedNarrative,
             rawConcept: mergedRawConcept,
+            reason: mergedReason,
             relations: mergedRelations,
             scoring: mergedScoringData,
             snippets: mergedSnippets,
+            summary: summary ?? sourceParsed.summary ?? targetParsed.summary,
             tags: mergedTags,
         });
     },
     parseContent(content, name = '') {
-        const { body, keywords, relations, scoring, tags, title } = parseContentWithFrontmatter(content);
+        const { body, keywords, relations, scoring, summary, tags, title } = parseContentWithFrontmatter(content);
         return {
             facts: parseFactsSection(body),
             keywords,
             name: title || name,
             narrative: parseNarrativeSection(body),
             rawConcept: parseRawConceptSection(body),
+            reason: parseReasonSection(body),
             relations,
             scoring,
             snippets: extractSnippetsFromContent(body),
+            summary,
             tags,
         };
     },

package/dist/server/core/domain/transport/schemas.d.ts

@@ -521,18 +521,18 @@ export declare const TaskExecuteSchema: z.ZodObject<{
     taskId: string;
     clientId: string;
     files?: string[] | undefined;
+    projectPath?: string | undefined;
     folderPath?: string | undefined;
     clientCwd?: string | undefined;
-    projectPath?: string | undefined;
 }, {
     type: "curate" | "query" | "curate-folder";
     content: string;
     taskId: string;
     clientId: string;
     files?: string[] | undefined;
+    projectPath?: string | undefined;
     folderPath?: string | undefined;
     clientCwd?: string | undefined;
-    projectPath?: string | undefined;
 }>;
 /**
  * task:cancel - Transport tells Agent to cancel a task
@@ -718,14 +718,14 @@ export declare const TaskStartedEventSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     taskId: string;
     type?: string | undefined;
-    content?: string | undefined;
     files?: string[] | undefined;
+    content?: string | undefined;
     clientCwd?: string | undefined;
 }, {
     taskId: string;
     type?: string | undefined;
-    content?: string | undefined;
     files?: string[] | undefined;
+    content?: string | undefined;
     clientCwd?: string | undefined;
 }>;
 /**
@@ -965,17 +965,17 @@ export declare const TaskCreateRequestSchema: z.ZodObject<{
     content: string;
     taskId: string;
     files?: string[] | undefined;
+    projectPath?: string | undefined;
     folderPath?: string | undefined;
     clientCwd?: string | undefined;
-    projectPath?: string | undefined;
 }, {
     type: "curate" | "query" | "curate-folder";
     content: string;
     taskId: string;
     files?: string[] | undefined;
+    projectPath?: string | undefined;
     folderPath?: string | undefined;
     clientCwd?: string | undefined;
-    projectPath?: string | undefined;
 }>;
 /**
  * Response after task creation

package/dist/server/core/interfaces/context-tree/i-context-tree-service.d.ts

@@ -15,6 +15,12 @@ export interface IContextTreeService {
      * @returns True if context tree directory exists
      */
     exists(directory?: string): Promise<boolean>;
+    /**
+     * Checks if a git repository (.git directory) exists in the context tree.
+     * @param directory - Base directory
+     * @returns True if .git directory exists inside the context tree
+     */
+    hasGitRepo(directory: string): Promise<boolean>;
     /**
      * Initializes the context tree directory structure.
      * Creates .brv/context-tree/ directory with domain subdirectories and context.md files.
@@ -23,4 +29,9 @@ export interface IContextTreeService {
      * @throws Error if context tree already exists or initialization fails
      */
     initialize(directory?: string): Promise<string>;
+    /**
+     * Returns the absolute path to the context tree directory without creating it.
+     * @param directory - Base directory
+     */
+    resolvePath(directory: string): string;
 }

package/dist/server/core/interfaces/process/i-task-lifecycle-hook.d.ts

@@ -12,6 +12,12 @@ import type { TaskInfo } from '../../domain/transport/task-info.js';
 export interface ITaskLifecycleHook {
     /** Called after onTaskCompleted, onTaskError, or onTaskCancelled to release in-memory resources. */
     cleanup?(taskId: string): void;
+    /**
+     * Synchronous hook called just before task:completed is emitted.
+     * Returns extra data to merge into the task:completed payload (e.g. {pendingReviewCount: 2}).
+     * Must be synchronous and must not throw.
+     */
+    getTaskCompletionData?(taskId: string): Record<string, unknown>;
     /** Called when a task is cancelled by the user. Distinct from onTaskError. */
     onTaskCancelled?(taskId: string, task: TaskInfo): Promise<void>;
     /** Called when a task completes successfully. */

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/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/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/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/connectors/rules/rules-connector-config.d.ts

@@ -101,7 +101,3 @@ export declare const RULES_CONNECTOR_CONFIGS: {
         readonly writeMode: "overwrite";
     };
 };
-/**
- * Type for agents that have rules connector configurations.
- */
-export type RulesSupportedAgent = keyof typeof RULES_CONNECTOR_CONFIGS;

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);
+    }
 }