byterover-cli 0.3.3 → 0.3.5

package/dist/commands/init.js

@@ -7,15 +7,16 @@ import { ACE_DIR, BRV_CONFIG_VERSION, BRV_DIR, DEFAULT_BRANCH, PROJECT_CONFIG_FI
 import { AGENT_VALUES } from '../core/domain/entities/agent.js';
 import { BrvConfig } from '../core/domain/entities/brv-config.js';
 import { BrvConfigVersionError } from '../core/domain/errors/brv-config-version-error.js';
-import { RuleExistsError } from '../core/domain/errors/rule-error.js';
 import { HttpCogitPullService } from '../infra/cogit/http-cogit-pull-service.js';
 import { ProjectConfigStore } from '../infra/config/file-config-store.js';
 import { FileContextTreeService } from '../infra/context-tree/file-context-tree-service.js';
 import { FileContextTreeSnapshotService } from '../infra/context-tree/file-context-tree-snapshot-service.js';
 import { FileContextTreeWriterService } from '../infra/context-tree/file-context-tree-writer-service.js';
 import { FsFileService } from '../infra/file/fs-file-service.js';
+import { AGENT_RULE_CONFIGS } from '../infra/rule/agent-rule-config.js';
+import { BRV_RULE_MARKERS, BRV_RULE_TAG } from '../infra/rule/constants.js';
+import { LegacyRuleDetector } from '../infra/rule/legacy-rule-detector.js';
 import { RuleTemplateService } from '../infra/rule/rule-template-service.js';
-import { RuleWriterService } from '../infra/rule/rule-writer-service.js';
 import { HttpSpaceService } from '../infra/space/http-space-service.js';
 import { KeychainTokenStore } from '../infra/storage/keychain-token-store.js';
 import { HttpTeamService } from '../infra/team/http-team-service.js';
@@ -88,6 +89,7 @@ export default class Init extends Command {
         const fileService = new FsFileService();
         const templateLoader = new FsTemplateLoader(fileService);
         const ruleTemplateService = new RuleTemplateService(templateLoader);
+        const legacyRuleDetector = new LegacyRuleDetector();
         const contextTreeSnapshotService = new FileContextTreeSnapshotService();
         return {
             cogitPullService: new HttpCogitPullService({
@@ -96,14 +98,17 @@ export default class Init extends Command {
             contextTreeService: new FileContextTreeService(),
             contextTreeSnapshotService,
             contextTreeWriterService: new FileContextTreeWriterService({ snapshotService: contextTreeSnapshotService }),
+            fileService,
+            legacyRuleDetector,
             projectConfigStore: new ProjectConfigStore(),
-            ruleWriterService: new RuleWriterService(fileService, ruleTemplateService),
+            // ruleWriterService: new RuleWriterService(fileService, ruleTemplateService),
             spaceService: new HttpSpaceService({
                 apiBaseUrl: envConfig.apiBaseUrl,
             }),
             teamService: new HttpTeamService({
                 apiBaseUrl: envConfig.apiBaseUrl,
             }),
+            templateService: ruleTemplateService,
             tokenStore,
             trackingService,
         };
@@ -150,27 +155,86 @@ export default class Init extends Command {
         this.log();
         return this.promptForTeamSelection(teams);
     }
-    async generateRulesForAgent(ruleWriterService, agent) {
-        this.log(`Generating rules for: ${agent}`);
-        try {
-            await ruleWriterService.writeRule(agent, false);
-            this.log(`✅ Successfully generated rule file for ${agent}`);
-        }
-        catch (error) {
-            if (error instanceof RuleExistsError) {
-                const overwrite = await this.promptForOverwriteConfirmation(agent);
-                if (overwrite) {
-                    await ruleWriterService.writeRule(agent, true);
-                    this.log(`✅ Successfully generated rule file for ${agent}`);
-                }
-                else {
-                    this.log(`Skipping rule file generation for ${agent}`);
-                }
+    async generateRulesForAgent(selectedAgent, fileService, templateService, legacyRuleDetector) {
+        this.log(`Generating rules for: ${selectedAgent}`);
+        // try {
+        //   await ruleWriterService.writeRule(agent, false)
+        //   this.log(`✅ Successfully generated rule file for ${agent}`)
+        // } catch (error) {
+        //   if (error instanceof RuleExistsError) {
+        //     const overwrite = await this.promptForOverwriteConfirmation(agent)
+        //     if (overwrite) {
+        //       await ruleWriterService.writeRule(agent, true)
+        //       this.log(`✅ Successfully generated rule file for ${agent}`)
+        //     } else {
+        //       this.log(`Skipping rule file generation for ${agent}`)
+        //     }
+        //   } else {
+        //     throw error
+        //   }
+        // }
+        const { filePath, writeMode } = AGENT_RULE_CONFIGS[selectedAgent];
+        // STEP 1: Check if file exists
+        const fileExists = await fileService.exists(filePath);
+        if (!fileExists) {
+            // Scenario A: File doesn't exist
+            const shouldCreate = await this.promptForFileCreation(selectedAgent, filePath);
+            if (!shouldCreate) {
+                this.log(`Skipped rule file creation for ${selectedAgent}`);
+                return;
             }
-            else {
-                throw error;
+            await this.createNewRuleFile({
+                agent: selectedAgent,
+                filePath,
+                fileService,
+                templateService,
+            });
+            return;
+        }
+        // STEP 2: File exists - read content
+        const content = await fileService.read(filePath);
+        // STEP 3: Check for LEGACY rules (priority: clean these up first)
+        const hasFooterTag = content.includes(`${BRV_RULE_TAG} ${selectedAgent}`);
+        const hasBoundaryMarkers = content.includes(BRV_RULE_MARKERS.START) && content.includes(BRV_RULE_MARKERS.END);
+        const hasLegacyRules = hasFooterTag && !hasBoundaryMarkers;
+        if (hasLegacyRules) {
+            // Scenario B: Legacy rules detected - handle cleanup
+            await this.handleLegacyRulesCleanup({
+                agent: selectedAgent,
+                content,
+                filePath,
+                fileService,
+                legacyRuleDetector,
+                templateService,
+            });
+            return;
+        }
+        // STEP 4: Check for NEW rules (boundary markers)
+        if (hasBoundaryMarkers) {
+            // Scenario C: New rules exist - prompt for overwrite
+            const shouldOverwrite = await this.promptForOverwriteConfirmation(selectedAgent);
+            if (!shouldOverwrite) {
+                this.log(`Skipped rule file update for ${selectedAgent}`);
+                return;
             }
+            await this.replaceExistingRules({
+                agent: selectedAgent,
+                content,
+                filePath,
+                fileService,
+                templateService,
+                writeMode,
+            });
+            return;
         }
+        // STEP 5: No ByteRover content - append rules
+        await this.appendRulesToFile({
+            agent: selectedAgent,
+            filePath,
+            fileService,
+            templateService,
+            writeMode,
+        });
     }
     async getExistingConfig(projectConfigStore) {
         const exists = await projectConfigStore.exists();
@@ -214,6 +278,14 @@ export default class Init extends Command {
     isLegacyProjectConfig(config) {
         return 'type' in config && config.type === 'legacy';
     }
+    /**
+     * Checks if the given path represents a README.md placeholder file.
+     * Handles both legacy paths with leading slash and new paths without.
+     */
+    isReadmePlaceholder(path) {
+        const normalizedPath = path.replace(/^\/+/, '');
+        return normalizedPath === 'README.md';
+    }
     async promptAceDeprecationRemoval() {
         this.log('\n The ACE system is being deprecated.');
         this.log(' ByteRover is migrating to the new Context Tree system for improved');
@@ -247,6 +319,41 @@ export default class Init extends Command {
         });
         return answer;
     }
+    /**
+     * Prompts the user to choose cleanup strategy for legacy rules.
+     * This method is protected to allow test overrides.
+     * @returns The chosen cleanup strategy
+     */
+    async promptForCleanupStrategy() {
+        return select({
+            choices: [
+                {
+                    description: 'New rules will be added with boundary markers. You manually remove old sections at your convenience.',
+                    name: 'Manual cleanup (recommended)',
+                    value: 'manual',
+                },
+                {
+                    description: '⚠️  We will remove all detected old sections. May cause content loss if detection is imperfect. A backup will be created.',
+                    name: 'Automatic cleanup',
+                    value: 'automatic',
+                },
+            ],
+            message: 'How would you like to proceed?',
+        });
+    }
+    /**
+     * Prompts the user to create a new rule file.
+     * This method is protected to allow test overrides.
+     * @param agent The agent for which the rule file doesn't exist
+     * @param filePath The path where the file would be created
+     * @returns True if the user wants to create the file, false otherwise
+     */
+    async promptForFileCreation(agent, filePath) {
+        return confirm({
+            default: true,
+            message: `Rule file '${filePath}' doesn't exist. Create it with ByteRover rules?`,
+        });
+    }
     /**
      * Prompts the user to confirm overwriting an existing rule file.
      * This method is protected to allow test overrides.
@@ -293,7 +400,9 @@ export default class Init extends Command {
     async run() {
         try {
             const { flags } = await this.parse(Init);
-            const { cogitPullService, contextTreeService, contextTreeSnapshotService, contextTreeWriterService, projectConfigStore, ruleWriterService, spaceService, teamService, tokenStore, trackingService, } = this.createServices();
+            const { cogitPullService, contextTreeService, contextTreeSnapshotService, contextTreeWriterService, fileService, legacyRuleDetector, projectConfigStore, 
+            // ruleWriterService,
+            spaceService, teamService, templateService, tokenStore, trackingService, } = this.createServices();
             const authToken = await this.ensureAuthenticated(tokenStore);
             const existingConfig = await this.getExistingConfig(projectConfigStore);
             if (existingConfig) {
@@ -346,7 +455,7 @@ export default class Init extends Command {
             await projectConfigStore.write(config);
             this.log(`\nGenerate rule instructions for coding agents to work with ByteRover correctly`);
             this.log();
-            await this.generateRulesForAgent(ruleWriterService, selectedAgent);
+            await this.generateRulesForAgent(selectedAgent, fileService, templateService, legacyRuleDetector);
             await trackingService.track('rule:generate');
             await trackingService.track('space:init');
             this.logSuccess(selectedSpace);
@@ -369,7 +478,7 @@ export default class Init extends Command {
             // Check if space is "empty" (no files, or only README.md placeholder)
             // CoGit follows Git semantics - empty repos have a README.md placeholder
             const isEmptySpace = coGitSnapshot.files.length === 0 ||
-                (coGitSnapshot.files.length === 1 && coGitSnapshot.files[0].path === '/README.md');
+                (coGitSnapshot.files.length === 1 && this.isReadmePlaceholder(coGitSnapshot.files[0].path));
             if (isEmptySpace) {
                 // Remote is empty - ignore placeholder, create templates with empty snapshot
                 await this.initializeMemoryContextDir('context tree', () => params.contextTreeService.initialize());
@@ -387,10 +496,139 @@ export default class Init extends Command {
             throw new Error(`Failed to sync from ByteRover: ${error instanceof Error ? error.message : 'Unknown error'}. Please try again.`);
         }
     }
+    /**
+     * Appends ByteRover rules to a file that has no ByteRover content.
+     */
+    async appendRulesToFile(params) {
+        const { agent, filePath, fileService, templateService, writeMode } = params;
+        const ruleContent = await templateService.generateRuleContent(agent);
+        // For dedicated ByteRover files, overwrite; for shared instruction files, append
+        const mode = writeMode === 'overwrite' ? 'overwrite' : 'append';
+        await fileService.write(ruleContent, filePath, mode);
+        this.log(`✅ Successfully added rule file for ${agent}`);
+    }
+    /**
+     * Creates a new rule file with ByteRover rules.
+     */
+    async createNewRuleFile(params) {
+        const { agent, filePath, fileService, templateService } = params;
+        const ruleContent = await templateService.generateRuleContent(agent);
+        await fileService.write(ruleContent, filePath, 'overwrite');
+        this.log(`✅ Successfully created rule file for ${agent} at ${filePath}`);
+    }
+    async handleLegacyRulesCleanup(params) {
+        const { agent, content, filePath, fileService, legacyRuleDetector, templateService } = params;
+        const detectionResult = legacyRuleDetector.detectLegacyRules(content, agent);
+        const { reliableMatches, uncertainMatches } = detectionResult;
+        this.log(`\n⚠️  Detected ${reliableMatches.length + uncertainMatches.length} old ByteRover rule section(s) in ${filePath}:\n`);
+        if (reliableMatches.length > 0) {
+            this.log('Reliable matches:');
+            for (const [index, match] of reliableMatches.entries()) {
+                this.log(`  Section ${index + 1}: lines ${match.startLine}-${match.endLine}`);
+            }
+            this.log();
+        }
+        if (uncertainMatches.length > 0) {
+            this.log('  ⚠️  Uncertain matches (cannot determine start):');
+            for (const match of uncertainMatches) {
+                this.log(`  Footer found at line ${match.footerLine}`);
+                this.log(`  Reason: ${match.reason}`);
+            }
+            this.log();
+            this.log('⚠️  Due to uncertain matches, only manual cleanup is available.\n');
+            await this.performManualCleanup({
+                agent,
+                filePath,
+                fileService,
+                reliableMatches,
+                templateService,
+                uncertainMatches,
+            });
+            return;
+        }
+        const selectedStrategy = await this.promptForCleanupStrategy();
+        await (selectedStrategy === 'manual'
+            ? this.performManualCleanup({
+                agent,
+                filePath,
+                fileService,
+                reliableMatches,
+                templateService,
+                uncertainMatches,
+            })
+            : this.performAutomaticCleanup({
+                agent,
+                filePath,
+                fileService,
+                reliableMatches,
+                templateService,
+            }));
+    }
     logSuccess(space) {
         this.log(`\n✓ Project initialized successfully!`);
         this.log(`✓ Connected to space: ${space.getDisplayName()}`);
         this.log(`✓ Configuration saved to: ${BRV_DIR}/${PROJECT_CONFIG_FILE}`);
         this.log("NOTE: It's recommended to add .brv/ to your .gitignore file since ByteRover already takes care of memory/context versioning for you.");
     }
+    async performAutomaticCleanup(params) {
+        const { agent, filePath, fileService, reliableMatches, templateService } = params;
+        const backupPath = await fileService.createBackup(filePath);
+        this.log(`📦 Backup created: ${backupPath}`);
+        let content = await fileService.read(filePath);
+        // Remove all reliable matches (in reverse order to preserve line numbers)
+        const sortedMatches = [...reliableMatches].sort((a, b) => b.startLine - a.startLine);
+        for (const match of sortedMatches) {
+            content = content.replace(match.content, '');
+        }
+        // Write cleaned content
+        await fileService.write(content, filePath, 'overwrite');
+        // Append new rules
+        const ruleContent = await templateService.generateRuleContent(agent);
+        await fileService.write(ruleContent, filePath, 'append');
+        this.log(`✅ Removed ${reliableMatches.length} old ByteRover section(s)`);
+        this.log(`✅ Added new rules with boundary markers`);
+        this.log(`\nYou can safely delete the backup file once verified.`);
+    }
+    async performManualCleanup(params) {
+        const { agent, filePath, fileService, reliableMatches, templateService, uncertainMatches } = params;
+        const ruleContent = await templateService.generateRuleContent(agent);
+        await fileService.write(ruleContent, filePath, 'append');
+        this.log(`✅ New ByteRover rules added with boundary markers\n`);
+        this.log('Please manually remove old sections:');
+        for (const [index, match] of reliableMatches.entries()) {
+            this.log(`  - Section ${index + 1}: lines ${match.startLine}-${match.endLine} in ${filePath}`);
+        }
+        for (const match of uncertainMatches) {
+            this.log(`  - Section ending at line ${match.footerLine} in ${filePath}`);
+        }
+        this.log('\nKeep only the section between:');
+        this.log('  <!-- BEGIN BYTEROVER RULES -->');
+        this.log('  <!-- END BYTEROVER RULES -->');
+    }
+    /**
+     * Replaces existing ByteRover rules (with boundary markers) with new rules.
+     */
+    async replaceExistingRules(params) {
+        const { agent, content, filePath, fileService, templateService, writeMode } = params;
+        const ruleContent = await templateService.generateRuleContent(agent);
+        if (writeMode === 'overwrite') {
+            // For dedicated ByteRover files, just overwrite the entire file
+            await fileService.write(ruleContent, filePath, 'overwrite');
+        }
+        else {
+            // For shared instruction files, replace the section between markers
+            const startMarker = BRV_RULE_MARKERS.START;
+            const endMarker = BRV_RULE_MARKERS.END;
+            const startIndex = content.indexOf(startMarker);
+            const endIndex = content.indexOf(endMarker, startIndex);
+            if (startIndex === -1 || endIndex === -1) {
+                this.error('Could not find boundary markers in the file');
+            }
+            const before = content.slice(0, startIndex);
+            const after = content.slice(endIndex + endMarker.length);
+            const newContent = before + ruleContent + after;
+            await fileService.write(newContent, filePath, 'overwrite');
+        }
+        this.log(`✅ Successfully updated rule file for ${agent}`);
+    }
 }

package/dist/core/domain/knowledge/directory-manager.js

@@ -138,6 +138,8 @@ export const DirectoryManager = {
      * @param content - Content to write
      */
     async writeFileAtomic(filePath, content) {
+        // Ensure parent directory exists before writing
+        await this.ensureParentDirectory(filePath);
         const tempPath = `${filePath}.tmp`;
         await fs.writeFile(tempPath, content, 'utf8');
         await fs.rename(tempPath, filePath);

package/dist/core/interfaces/i-file-service.d.ts

@@ -8,6 +8,13 @@ export type WriteMode = 'append' | 'overwrite';
  * Interface for file service operations.
  */
 export interface IFileService {
+    /**
+     * Creates a timestamped backup copy of a file.
+     *
+     * @param filePath The path to the file to backup.
+     * @returns A promise that resolves with the path to the backup file.
+     */
+    createBackup: (filePath: string) => Promise<string>;
     /**
      * Checks if a file exists at the specified path.
      *
@@ -22,6 +29,15 @@ export interface IFileService {
      * @returns A promise that resolves with the content of the file.
      */
     read: (filePath: string) => Promise<string>;
+    /**
+     * Replaces specific content within a file with new content.
+     *
+     * @param filePath The path to the file.
+     * @param oldContent The content to be replaced.
+     * @param newContent The new content to insert.
+     * @returns A promise that resolves when the replacement is complete.
+     */
+    replaceContent: (filePath: string, oldContent: string, newContent: string) => Promise<void>;
     /**
      * Writes content to the specified file.
      *

package/dist/core/interfaces/i-legacy-rule-detector.d.ts

@@ -0,0 +1,56 @@
+import type { Agent } from '../domain/entities/agent.js';
+/**
+ * Represents a reliably detected legacy ByteRover rule section.
+ */
+export type LegacyRuleMatch = {
+    /**
+     * Content of the detected section.
+     */
+    content: string;
+    /**
+     * Ending line number (1-indexed)
+     */
+    endLine: number;
+    /**
+     * Starting line number (1-indexed)
+     */
+    startLine: number;
+};
+/**
+ * Represents an uncertain detection where the footer was found but start couldn't be reliably determined.
+ */
+export type UncertainMatch = {
+    /**
+     * Line number where the footer tag was found (1-indexed).
+     */
+    footerLine: number;
+    /**
+     * Reason why the start couldn't be determined.
+     */
+    reason: string;
+};
+/**
+ * Result of detecting legacy ByteRover rules in a file.
+ */
+export type LegacyRuleDetectionResult = {
+    /**
+     * Reliably detected rule sections with known start and end positions.
+     */
+    reliableMatches: LegacyRuleMatch[];
+    /**
+     * Uncertain matches where only the footer was found.
+     */
+    uncertainMatches: UncertainMatch[];
+};
+/**
+ * Service for detecting legacy ByteRover rules (without boundary markers) in instruction files.
+ */
+export interface ILegacyRuleDetector {
+    /**
+     * Detects legacy ByteRover rule sections in file content.
+     * @param content The file content to analyze.
+     * @param agentName The agent name to look for in the footer tag.
+     * @returns Detection result with reliable and uncertain matches.
+     */
+    detectLegacyRules: (content: string, agentName: Agent) => LegacyRuleDetectionResult;
+}

package/dist/hooks/init/update-notifier.d.ts

@@ -0,0 +1,39 @@
+import type { Hook } from '@oclif/core';
+/**
+ * Check interval for update notifications (24 hours)
+ */
+export declare const UPDATE_CHECK_INTERVAL_MS: number;
+/**
+ * Narrowed notifier type for dependency injection
+ */
+export type NarrowedUpdateNotifier = {
+    notify: (options: {
+        defer: boolean;
+        message: string;
+    }) => void;
+    update?: {
+        current: string;
+        latest: string;
+    };
+};
+/**
+ * Dependencies that can be injected for testing
+ */
+export type UpdateNotifierDeps = {
+    confirmPrompt: (options: {
+        default: boolean;
+        message: string;
+    }) => Promise<boolean>;
+    execSyncFn: (command: string, options: {
+        stdio: 'inherit';
+    }) => void;
+    isTTY: boolean;
+    log: (message: string) => void;
+    notifier: NarrowedUpdateNotifier;
+};
+/**
+ * Core update notification logic, extracted for testability
+ */
+export declare function handleUpdateNotification(deps: UpdateNotifierDeps): Promise<void>;
+declare const hook: Hook<'init'>;
+export default hook;

package/dist/hooks/init/update-notifier.js

@@ -0,0 +1,43 @@
+import { confirm } from '@inquirer/prompts';
+import { execSync } from 'node:child_process';
+import updateNotifier from 'update-notifier';
+/**
+ * Check interval for update notifications (24 hours)
+ */
+export const UPDATE_CHECK_INTERVAL_MS = 1000 * 60 * 60 * 24;
+/**
+ * Core update notification logic, extracted for testability
+ */
+export async function handleUpdateNotification(deps) {
+    const { confirmPrompt, execSyncFn, isTTY, log, notifier } = deps;
+    if (!notifier.update || !isTTY) {
+        return;
+    }
+    const { current, latest } = notifier.update;
+    const shouldUpdate = await confirmPrompt({
+        default: true,
+        message: `Update available: ${current} → ${latest}. Would you like to update now?`,
+    });
+    if (shouldUpdate) {
+        log('Updating byterover-cli...');
+        try {
+            execSyncFn('npm update -g byterover-cli', { stdio: 'inherit' });
+            log(`✓ Successfully updated to ${latest}`);
+        }
+        catch {
+            log('⚠️  Automatic update failed. Please run manually: npm update -g byterover-cli');
+        }
+    }
+}
+const hook = async function () {
+    const pkgInfo = { name: this.config.name, version: this.config.version };
+    const notifier = updateNotifier({ pkg: pkgInfo, updateCheckInterval: UPDATE_CHECK_INTERVAL_MS });
+    await handleUpdateNotification({
+        confirmPrompt: confirm,
+        execSyncFn: execSync,
+        isTTY: process.stdout.isTTY ?? false,
+        log: this.log.bind(this),
+        notifier,
+    });
+};
+export default hook;

package/dist/infra/cipher/llm/generators/byterover-content-generator.js

@@ -4,6 +4,7 @@
  * Implements IContentGenerator using ByteRover gRPC service.
  * Supports both Claude and Gemini models through the unified gRPC interface.
  */
+import { FunctionCallingConfigMode } from '@google/genai';
 import { ClaudeMessageFormatter } from '../formatters/claude-formatter.js';
 import { GeminiMessageFormatter } from '../formatters/gemini-formatter.js';
 import { ThinkingConfigManager } from '../thought-parser.js';
@@ -164,6 +165,11 @@ export class ByteRoverContentGenerator {
             topP: 1,
             ...(systemPrompt && { systemInstruction: { parts: [{ text: systemPrompt }] } }),
             ...(toolDefinitions.length > 0 && {
+                toolConfig: {
+                    functionCallingConfig: {
+                        mode: FunctionCallingConfigMode.VALIDATED,
+                    },
+                },
                 tools: [
                     {
                         functionDeclarations: toolDefinitions,

package/dist/infra/cogit/context-tree-to-push-context-mapper.js

@@ -10,21 +10,21 @@ export const mapToPushContexts = (params) => {
     const addedContextFiles = params.addedFiles.map((file) => new CogitPushContext({
         content: file.content,
         operation: 'add',
-        path: `/${file.path}`,
+        path: file.path,
         tags: [],
         title: file.title,
     }));
     const editedContextFiles = params.modifiedFiles.map((file) => new CogitPushContext({
         content: file.content,
         operation: 'edit',
-        path: `/${file.path}`,
+        path: file.path,
         tags: [],
         title: file.title,
     }));
-    const deletedContextFiles = params.deletedPaths.map((path) => new CogitPushContext({
+    const deletedContextFiles = params.deletedPaths.map((deletedPath) => new CogitPushContext({
         content: '',
         operation: 'delete',
-        path: `/${path}`,
+        path: deletedPath,
         tags: [],
         title: '',
     }));

package/dist/infra/cogit/http-cogit-push-service.js

@@ -40,7 +40,7 @@ export class HttpCogitPushService {
             const response = await this.makeRequest({
                 accessToken: params.accessToken,
                 branch: params.branch,
-                currentSha: '',
+                currentSha: 'sha_placeholder',
                 memories,
                 sessionKey: params.sessionKey,
                 url,
@@ -79,8 +79,8 @@ export class HttpCogitPushService {
             typeof error.response === 'object' &&
             'data' in error.response) {
             const errorResponse = error.response.data;
-            if (errorResponse.details) {
-                return extractShaFromErrorDetails(errorResponse.details);
+            if (errorResponse.error) {
+                return extractShaFromErrorDetails(errorResponse.error);
             }
         }
         return undefined;

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

@@ -17,6 +17,8 @@ export declare class FileContextTreeWriterService implements IContextTreeWriterS
     sync(params: SyncParams): Promise<SyncResult>;
     /**
      * Normalizes a file path by removing leading slashes.
+     * Retained for backwards compatibility with legacy API responses
+     * that may still include leading slashes in paths.
      */
     private normalizePath;
 }

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

@@ -54,6 +54,8 @@ export class FileContextTreeWriterService {
     }
     /**
      * Normalizes a file path by removing leading slashes.
+     * Retained for backwards compatibility with legacy API responses
+     * that may still include leading slashes in paths.
      */
     normalizePath(path) {
         return path.replace(/^\/+/, '');

package/dist/infra/file/fs-file-service.d.ts

@@ -3,6 +3,7 @@ import { type IFileService, type WriteMode } from '../../core/interfaces/i-file-
  * File service implementation using Node.js fs module.
  */
 export declare class FsFileService implements IFileService {
+    createBackup(filePath: string): Promise<string>;
     /**
      * Checks if a file exists at the specified path.
      *
@@ -17,6 +18,7 @@ export declare class FsFileService implements IFileService {
      * @returns A promise that resolves with the content of the file.
      */
     read(filePath: string): Promise<string>;
+    replaceContent(filePath: string, oldContent: string, newContent: string): Promise<void>;
     /**
      * Writes content to the specified file.
      * @param content The content to write.