byterover-cli 0.2.0 → 0.3.0

package/dist/infra/cipher/tools/default-policy-rules.js

@@ -0,0 +1,125 @@
+/**
+ * Default Policy Rules for Autonomous Execution.
+ *
+ * These rules define the default behavior for tool execution in autonomous mode.
+ * All tools are ALLOWED by default since the agent runs without user approval.
+ *
+ * DENY rules are only for truly dangerous operations that should never run,
+ * such as destructive commands that could harm the system.
+ */
+/**
+ * Default policy rules for autonomous execution.
+ *
+ * Rule evaluation order:
+ * 1. DENY rules for dangerous operations (evaluated first via conditions)
+ * 2. ALLOW rules for all known tool categories
+ * 3. Default ALLOW for any unlisted tools
+ */
+export const DEFAULT_POLICY_RULES = [
+    // ============================================
+    // DENY rules for dangerous operations
+    // ============================================
+    /**
+     * Deny destructive root filesystem deletion.
+     * Matches: rm -rf / , rm -r / , rm -f /
+     */
+    {
+        condition(_, args) {
+            const command = String(args.command || '');
+            // Match rm with -r or -f flags targeting root /
+            // Negative lookahead (?!\w) ensures / is not followed by word chars
+            return /rm\s+(-[rf]+\s+)+\/(?!\w)/.test(command);
+        },
+        decision: 'DENY',
+        name: 'deny-rm-rf-root',
+        reason: 'Destructive root filesystem deletion not allowed',
+        toolPattern: 'bash_exec',
+    },
+    /**
+     * Deny format commands on disk devices.
+     */
+    {
+        condition(_, args) {
+            const command = String(args.command || '');
+            return /mkfs\.|format\s+[cdefg]:/i.test(command);
+        },
+        decision: 'DENY',
+        name: 'deny-format-disk',
+        reason: 'Disk formatting not allowed',
+        toolPattern: 'bash_exec',
+    },
+    /**
+     * Deny dd commands that could overwrite disks.
+     */
+    {
+        condition(_, args) {
+            const command = String(args.command || '');
+            return /dd\s+.*of=\/dev\/(sd[a-z]|hd[a-z]|nvme|disk)/i.test(command);
+        },
+        decision: 'DENY',
+        name: 'deny-dd-disk',
+        reason: 'Direct disk write with dd not allowed',
+        toolPattern: 'bash_exec',
+    },
+    // ============================================
+    // ALLOW rules for tool categories
+    // ============================================
+    /**
+     * Allow all read operations (safe by default).
+     */
+    {
+        decision: 'ALLOW',
+        name: 'allow-read-tools',
+        reason: 'Read operations are safe',
+        toolPattern: /^(read_file|glob_files|grep_content|list_memories|read_memory|search_history|find_knowledge_topics)$/,
+    },
+    /**
+     * Allow all write operations (autonomous mode).
+     */
+    {
+        decision: 'ALLOW',
+        name: 'allow-write-tools',
+        reason: 'Write operations allowed in autonomous mode',
+        toolPattern: /^(write_file|edit_file|write_memory|edit_memory|delete_memory|create_knowledge_topic)$/,
+    },
+    /**
+     * Allow bash execution (autonomous mode, with DENY rules above as safety net).
+     */
+    {
+        decision: 'ALLOW',
+        name: 'allow-bash-tools',
+        reason: 'Shell execution allowed in autonomous mode',
+        toolPattern: /^(bash_exec|bash_output|kill_process)$/,
+    },
+    /**
+     * Allow discovery/exploration tools.
+     */
+    {
+        decision: 'ALLOW',
+        name: 'allow-discovery-tools',
+        reason: 'Discovery operations are safe',
+        toolPattern: /^(detect_domains)$/,
+    },
+    // ============================================
+    // Catch-all ALLOW for any other tools
+    // ============================================
+    /**
+     * Allow all other tools by default.
+     * This ensures new tools work without explicit rules.
+     */
+    {
+        decision: 'ALLOW',
+        name: 'allow-all-default',
+        reason: 'Default allow for autonomous mode',
+        toolPattern: '*',
+    },
+];
+/**
+ * Create a copy of the default rules.
+ * Useful when you want to modify rules without affecting the defaults.
+ *
+ * @returns A new array with copies of the default rules
+ */
+export function createDefaultPolicyRules() {
+    return DEFAULT_POLICY_RULES.map((rule) => ({ ...rule }));
+}

package/dist/infra/cipher/tools/implementations/bash-exec-tool.d.ts

@@ -0,0 +1,12 @@
+import type { Tool } from '../../../../core/domain/cipher/tools/types.js';
+import type { IProcessService } from '../../../../core/interfaces/cipher/i-process-service.js';
+/**
+ * Create bash_exec tool.
+ *
+ * Executes shell commands with security validation and approval for dangerous commands.
+ * Supports both foreground (wait for completion) and background (return immediately) execution.
+ *
+ * @param processService - Process service for command execution
+ * @returns bash_exec tool instance
+ */
+export declare function createBashExecTool(processService: IProcessService): Tool;

package/dist/infra/cipher/tools/implementations/bash-exec-tool.js

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+import { ToolName } from '../../../../core/domain/cipher/tools/constants.js';
+/**
+ * Input schema for bash_exec tool.
+ */
+const BashExecInputSchema = z
+    .object({
+    /**
+     * Shell command to execute.
+     */
+    command: z.string().describe('Shell command to execute'),
+    /**
+     * Working directory for command execution (relative to configured base directory).
+     */
+    cwd: z.string().optional().describe('Working directory for command execution'),
+    /**
+     * Human-readable description of what the command does (5-10 words).
+     */
+    description: z.string().optional().describe('Description of what the command does (5-10 words)'),
+    /**
+     * Execute command in background (returns immediately with process handle).
+     */
+    runInBackground: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Execute command in background'),
+    /**
+     * Timeout in milliseconds (max: 600000).
+     */
+    timeout: z
+        .number()
+        .int()
+        .positive()
+        .max(600_000)
+        .optional()
+        .default(120_000)
+        .describe('Timeout in milliseconds'),
+})
+    .strict();
+/**
+ * Create bash_exec tool.
+ *
+ * Executes shell commands with security validation and approval for dangerous commands.
+ * Supports both foreground (wait for completion) and background (return immediately) execution.
+ *
+ * @param processService - Process service for command execution
+ * @returns bash_exec tool instance
+ */
+export function createBashExecTool(processService) {
+    return {
+        description: `Execute a shell command and return its output.
+
+If there is a memory about suggested commands, read that first.
+
+**IMPORTANT:** Do not use this tool to start any process that is not intended to terminate quickly, or requires user interaction.
+
+Examples of inappropriate use:
+- Long-running processes (e.g. servers) that are not intended to terminate quickly
+- Processes that require user interaction`,
+        async execute(input, _context) {
+            const { command, cwd, description, runInBackground, timeout } = input;
+            // Execute command via process service
+            const result = await processService.executeCommand(command, {
+                cwd,
+                description,
+                runInBackground,
+                timeout,
+            });
+            // Return based on execution mode
+            if ('stdout' in result) {
+                // Foreground execution result
+                return {
+                    duration: result.duration,
+                    exitCode: result.exitCode,
+                    stderr: result.stderr,
+                    stdout: result.stdout,
+                };
+            }
+            // Background execution handle
+            return {
+                command: result.command,
+                description: result.description,
+                message: `Process started in background. Use bash_output with processId="${result.processId}" to retrieve output.`,
+                pid: result.pid,
+                processId: result.processId,
+                startedAt: result.startedAt.toISOString(),
+            };
+        },
+        id: ToolName.BASH_EXEC,
+        inputSchema: BashExecInputSchema,
+    };
+}

package/dist/infra/cipher/tools/implementations/bash-output-tool.d.ts

@@ -0,0 +1,12 @@
+import type { Tool } from '../../../../core/domain/cipher/tools/types.js';
+import type { IProcessService } from '../../../../core/interfaces/cipher/i-process-service.js';
+/**
+ * Create bash_output tool.
+ *
+ * Retrieves output from a background process started by bash_exec.
+ * Reading output clears the buffer (destructive read), so output is only returned once.
+ *
+ * @param processService - Process service for retrieving output
+ * @returns bash_output tool instance
+ */
+export declare function createBashOutputTool(processService: IProcessService): Tool;

package/dist/infra/cipher/tools/implementations/bash-output-tool.js

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { ToolName } from '../../../../core/domain/cipher/tools/constants.js';
+/**
+ * Input schema for bash_output tool.
+ */
+const BashOutputInputSchema = z
+    .object({
+    /**
+     * Unique process identifier from bash_exec.
+     */
+    processId: z.string().describe('Unique process identifier from bash_exec'),
+})
+    .strict();
+/**
+ * Create bash_output tool.
+ *
+ * Retrieves output from a background process started by bash_exec.
+ * Reading output clears the buffer (destructive read), so output is only returned once.
+ *
+ * @param processService - Process service for retrieving output
+ * @returns bash_output tool instance
+ */
+export function createBashOutputTool(processService) {
+    return {
+        description: `Retrieve output from a background process started by bash_exec.
+
+Returns new output since last read (incremental). Reading output clears the buffer, so output is returned only once. Shows process status (running/completed/failed) and includes exit code and duration when completed.
+
+**IMPORTANT:** Output is truncated if it exceeds buffer limit (default 1MB). Process is automatically cleaned up 1 hour after completion.`,
+        async execute(input, _context) {
+            const { processId } = input;
+            // Get output from process service
+            const output = await processService.getProcessOutput(processId);
+            // Return output with status
+            return {
+                duration: output.duration,
+                exitCode: output.exitCode,
+                processId,
+                status: output.status,
+                stderr: output.stderr,
+                stdout: output.stdout,
+            };
+        },
+        id: ToolName.BASH_OUTPUT,
+        inputSchema: BashOutputInputSchema,
+    };
+}

package/dist/infra/cipher/tools/implementations/create-knowledge-topic-tool.d.ts

@@ -0,0 +1,11 @@
+import type { Tool } from '../../../../core/domain/cipher/tools/types.js';
+/**
+ * Creates the create knowledge topic tool.
+ *
+ * Creates organized knowledge topics within domain folders, where each topic and subtopic
+ * has its own folder containing a context.md file with relevant snippets. This tool should
+ * be used after detecting domains to organize the extracted knowledge into a structured hierarchy.
+ *
+ * @returns Configured create knowledge topic tool
+ */
+export declare function createCreateKnowledgeTopicTool(): Tool;

package/dist/infra/cipher/tools/implementations/create-knowledge-topic-tool.js

@@ -0,0 +1,142 @@
+import { join } from 'node:path';
+import { z } from 'zod';
+import { ToolName } from '../../../../core/domain/cipher/tools/constants.js';
+import { DirectoryManager } from '../../../../core/domain/knowledge/directory-manager.js';
+import { MarkdownWriter } from '../../../../core/domain/knowledge/markdown-writer.js';
+import { sanitizeFolderName } from '../../../../utils/file-helpers.js';
+const CreateKnowledgeTopicInputSchema = z.object({
+    // Base path for knowledge storage
+    basePath: z.string().default('.brv/context-tree'),
+    domains: z.array(z.string()).describe('Array of domain names'),
+    // Manual topics (optional)
+    topics: z
+        .array(z.object({
+        domain: z.string().describe('Domain category name from predefined list'),
+        name: z.string().describe('Topic name'),
+        relations: z
+            .array(z.string())
+            .optional()
+            .describe('Related topics using @domain/topic or @domain/topic/subtopic notation'),
+        snippets: z.array(z.string()).describe('Code/text snippets'),
+        subtopics: z
+            .array(z.object({
+            name: z.string().describe('Subtopic name'),
+            relations: z
+                .array(z.string())
+                .optional()
+                .describe('Related topics using @domain/topic or @domain/topic/subtopic notation'),
+            snippets: z.array(z.string()).describe('Code/text snippets'),
+        }))
+            .describe('Array of subtopics'),
+    }))
+        .describe('Array of topics for each domain'),
+});
+/**
+ * Execute function for create knowledge topic tool
+ */
+async function executeCreateKnowledgeTopic(input, _context) {
+    const { basePath, topics } = input;
+    // Ensure base knowledge structure exists
+    await DirectoryManager.ensureKnowledgeStructure(basePath);
+    const created = [];
+    const updated = [];
+    // Process each topic sequentially (domains/topics must be created in order)
+    /* eslint-disable no-await-in-loop -- Sequential processing required for domain/topic hierarchy */
+    for (const topicData of topics) {
+        const { domain, name: topicName, relations, snippets, subtopics: subtopicData } = topicData;
+        // Create or update domain folder
+        const domainPath = join(basePath, sanitizeFolderName(domain));
+        const domainResult = await DirectoryManager.createOrUpdateDomain(domainPath);
+        // Create or update topic folder
+        const topicPath = join(domainPath, sanitizeFolderName(topicName));
+        const topicResult = await DirectoryManager.createOrUpdateTopic(topicPath);
+        // Generate and write topic context.md
+        const topicContextContent = MarkdownWriter.generateContext({
+            name: topicName,
+            relations,
+            snippets,
+        });
+        const topicContextPath = join(topicPath, 'context.md');
+        await DirectoryManager.writeFileAtomic(topicContextPath, topicContextContent);
+        // Process subtopics in parallel
+        const subtopicResults = await Promise.all(subtopicData.map(async (subtopic) => {
+            // Create subtopic folder
+            const subtopicPath = join(topicPath, sanitizeFolderName(subtopic.name));
+            const subtopicResult = await DirectoryManager.createOrUpdateTopic(subtopicPath);
+            // Generate and write subtopic context.md
+            const subtopicContextContent = MarkdownWriter.generateContext({
+                name: subtopic.name,
+                relations: subtopic.relations,
+                snippets: subtopic.snippets,
+            });
+            const subtopicContextPath = join(subtopicPath, 'context.md');
+            await DirectoryManager.writeFileAtomic(subtopicContextPath, subtopicContextContent);
+            return {
+                existed: !subtopicResult.created,
+                name: subtopic.name,
+            };
+        }));
+        // Separate created vs updated subtopics
+        const createdSubtopics = subtopicResults.filter((r) => !r.existed).map((r) => r.name);
+        const updatedSubtopics = subtopicResults.filter((r) => r.existed).map((r) => r.name);
+        // Track what was created vs updated
+        if (domainResult.created || topicResult.created) {
+            created.push({
+                domain,
+                subtopics: createdSubtopics,
+                topic: topicName,
+            });
+        }
+        else {
+            updated.push({
+                domain,
+                subtopics: updatedSubtopics,
+                topic: topicName,
+            });
+        }
+    }
+    /* eslint-enable no-await-in-loop */
+    return {
+        created,
+        updated,
+    };
+}
+/**
+ * Creates the create knowledge topic tool.
+ *
+ * Creates organized knowledge topics within domain folders, where each topic and subtopic
+ * has its own folder containing a context.md file with relevant snippets. This tool should
+ * be used after detecting domains to organize the extracted knowledge into a structured hierarchy.
+ *
+ * @returns Configured create knowledge topic tool
+ */
+export function createCreateKnowledgeTopicTool() {
+    return {
+        description: `Create organized knowledge topics within domain folders. This tool structures knowledge by creating topic and subtopic folders, each containing a context.md file with relevant snippets and optional relations.
+
+Use this tool after detecting domains to organize extracted knowledge into a hierarchical structure:
+- Domain folders (e.g., .brv/context-tree/domain-name/)
+- Topic folders (e.g., .brv/context-tree/domain-name/topic-name/)
+- Topic context.md files (e.g., .brv/context-tree/domain-name/topic-name/context.md)
+- Subtopic folders (e.g., .brv/context-tree/domain-name/topic-name/subtopic-name/)
+- Subtopic context.md files (e.g., .brv/context-tree/domain-name/topic-name/subtopic-name/context.md)
+
+Each topic should include:
+1. A clear topic name
+2. Relevant code/text snippets that demonstrate the knowledge
+3. Optional relations to other topics using @domain/topic or @domain/topic/subtopic notation
+4. Subtopics (optional) that break down the topic into smaller pieces
+
+Relations enhance knowledge discovery by linking related contexts. Example:
+- relations: ['code_style/error-handling', 'structure/api-endpoints/validation']
+
+The tool automatically:
+- Creates the base knowledge structure if it doesn't exist
+- Creates topic and subtopic folders as needed
+- Generates context.md files with snippets and relations
+- Handles existing topics gracefully (updates instead of recreating)`,
+        execute: executeCreateKnowledgeTopic,
+        id: ToolName.CREATE_KNOWLEDGE_TOPIC,
+        inputSchema: CreateKnowledgeTopicInputSchema,
+    };
+}

package/dist/infra/cipher/tools/implementations/delete-memory-tool.d.ts

@@ -0,0 +1,12 @@
+import type { Tool } from '../../../../core/domain/cipher/tools/types.js';
+import type { MemoryManager } from '../../memory/memory-manager.js';
+/**
+ * Delete memory tool.
+ *
+ * Removes a memory from the scratch pad. Also deletes any blob attachments
+ * associated with the memory. Use this to clean up outdated or unnecessary context.
+ *
+ * @param memoryManager - Memory manager service dependency
+ * @returns Configured delete memory tool
+ */
+export declare function createDeleteMemoryTool(memoryManager: MemoryManager): Tool;

package/dist/infra/cipher/tools/implementations/delete-memory-tool.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { ToolName } from '../../../../core/domain/cipher/tools/constants.js';
+/**
+ * Input schema for delete memory tool.
+ */
+const DeleteMemoryInputSchema = z
+    .object({
+    id: z.string().min(1).describe('Unique identifier of the memory to delete'),
+})
+    .strict();
+/**
+ * Delete memory tool.
+ *
+ * Removes a memory from the scratch pad. Also deletes any blob attachments
+ * associated with the memory. Use this to clean up outdated or unnecessary context.
+ *
+ * @param memoryManager - Memory manager service dependency
+ * @returns Configured delete memory tool
+ */
+export function createDeleteMemoryTool(memoryManager) {
+    return {
+        description: 'Delete a memory by ID. Removes the memory and all associated attachments from the scratch pad. Use this to clean up outdated context.',
+        async execute(input, _context) {
+            const { id } = input;
+            // Delete memory
+            await memoryManager.delete(id);
+            // Return confirmation
+            return {
+                deleted: true,
+                id,
+                message: `Memory ${id} has been deleted successfully`,
+            };
+        },
+        id: ToolName.DELETE_MEMORY,
+        inputSchema: DeleteMemoryInputSchema,
+    };
+}

package/dist/infra/cipher/tools/implementations/detect-domains-tool.d.ts

@@ -0,0 +1,7 @@
+import type { Tool } from '../../../../core/domain/cipher/tools/types.js';
+/**
+ * Creates the detect domains tool.
+ *
+ * @returns Configured detect domains tool
+ */
+export declare function createDetectDomainsTool(): Tool;

package/dist/infra/cipher/tools/implementations/detect-domains-tool.js

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import { CONTEXT_TREE_DOMAINS } from '../../../../config/context-tree-domains.js';
+import { ToolName } from '../../../../core/domain/cipher/tools/constants.js';
+/**
+ * Predefined domain category names for validation reference
+ */
+const PREDEFINED_DOMAIN_NAMES = CONTEXT_TREE_DOMAINS.map((domain) => domain.name);
+/**
+ * Domain category for knowledge classification.
+ */
+const DomainCategory = z
+    .string()
+    .min(1)
+    .describe(`Domain category name. Must be one of the predefined categories: ${PREDEFINED_DOMAIN_NAMES.join(', ')}`);
+/**
+ * Text segment schema - represents a portion of the input data related to a domain
+ */
+const TextSegmentSchema = z
+    .string()
+    .min(1)
+    .describe('A segment of text from the input data that relates to this domain category');
+/**
+ * Input schema for detect domains tool
+ */
+const DetectDomainsInputSchema = z
+    .object({
+    /** Detected domains with metadata and related text segments */
+    domains: z
+        .array(z.object({
+        category: DomainCategory.describe('Domain category name from predefined list'),
+        textSegments: z
+            .array(TextSegmentSchema)
+            .min(1)
+            .describe('Array of text segments from the input data that relate to this domain. Each segment should be a meaningful excerpt that demonstrates why this domain is relevant.'),
+    }))
+        .describe('Array of detected domains with their related text segments from the input data'),
+});
+/**
+ * Execute function for detect domains tool with typed input
+ */
+async function executeDetectDomains(input, _context) {
+    const { domains } = input;
+    return {
+        domains,
+    };
+}
+/**
+ * Creates the detect domains tool.
+ *
+ * @returns Configured detect domains tool
+ */
+export function createDetectDomainsTool() {
+    const domainDescriptions = CONTEXT_TREE_DOMAINS.map((domain) => `  - ${domain.name}: ${domain.description}`).join('\n');
+    return {
+        description: `Use this tool to analyze input data and detect which predefined knowledge domains are present. For each detected domain, you must also extract the specific text segments from the input data that relate to that domain.
+
+This tool should be the first tool to call when you want to understand new data, unless you already know what you are looking for.
+
+Predefined domain categories:
+${domainDescriptions}
+
+For each domain you detect:
+1. Identify the domain category (must be one of the predefined categories above)
+2. Extract relevant text segments from the input data that demonstrate why this domain is relevant
+3. Each text segment should be a meaningful excerpt (not just keywords) that shows the connection to the domain
+4. Only include domains that are actually present in the data - do not include domains just because they exist in the predefined list
+
+The text segments will be used later to create organized knowledge topics, so they should be substantial enough to provide context.`,
+        execute: executeDetectDomains,
+        id: ToolName.DETECT_DOMAINS,
+        inputSchema: DetectDomainsInputSchema,
+    };
+}

package/dist/infra/cipher/tools/implementations/edit-file-tool.d.ts

@@ -0,0 +1,13 @@
+import type { Tool } from '../../../../core/domain/cipher/tools/types.js';
+import type { IFileSystem } from '../../../../core/interfaces/cipher/i-file-system.js';
+/**
+ * Creates the edit file tool.
+ *
+ * Edits a file by replacing text.
+ * By default, requires oldString to be unique (only one occurrence).
+ * Set replaceAll to true to replace all occurrences.
+ *
+ * @param fileSystemService - File system service dependency
+ * @returns Configured edit file tool
+ */
+export declare function createEditFileTool(fileSystemService: IFileSystem): Tool;

package/dist/infra/cipher/tools/implementations/edit-file-tool.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { ToolName } from '../../../../core/domain/cipher/tools/constants.js';
+/**
+ * Input schema for edit file tool.
+ */
+const EditFileInputSchema = z
+    .object({
+    filePath: z.string().describe('Absolute path to the file to edit'),
+    newString: z.string().describe('Replacement text'),
+    oldString: z.string().describe('Text to replace (must be unique unless replaceAll is true)'),
+    replaceAll: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe('Replace all occurrences (default: false, requires unique match)'),
+})
+    .strict();
+/**
+ * Creates the edit file tool.
+ *
+ * Edits a file by replacing text.
+ * By default, requires oldString to be unique (only one occurrence).
+ * Set replaceAll to true to replace all occurrences.
+ *
+ * @param fileSystemService - File system service dependency
+ * @returns Configured edit file tool
+ */
+export function createEditFileTool(fileSystemService) {
+    return {
+        description: 'Edit a file by replacing text. By default requires unique match (set replaceAll=true for multiple replacements).',
+        async execute(input, _context) {
+            const { filePath, newString, oldString, replaceAll } = input;
+            // Call file system service
+            const result = await fileSystemService.editFile(filePath, {
+                newString,
+                oldString,
+                replaceAll,
+            }, {});
+            // Return formatted result
+            return {
+                bytesWritten: result.bytesWritten,
+                path: result.path,
+                replacements: result.replacements,
+                success: result.success,
+            };
+        },
+        id: ToolName.EDIT_FILE,
+        inputSchema: EditFileInputSchema,
+    };
+}

package/dist/infra/cipher/tools/implementations/edit-memory-tool.d.ts

@@ -0,0 +1,13 @@
+import type { Tool } from '../../../../core/domain/cipher/tools/types.js';
+import type { MemoryManager } from '../../memory/memory-manager.js';
+/**
+ * Creates the edit memory tool.
+ *
+ * Updates an existing memory's content, tags, or pinned status. Metadata is merged
+ * while content and tags are replaced if provided. Use this to refine or update
+ * context in the scratch pad.
+ *
+ * @param memoryManager - Memory manager service dependency
+ * @returns Configured edit memory tool
+ */
+export declare function createEditMemoryTool(memoryManager: MemoryManager): Tool;