codehere 0.2.2 → 0.3.0-rc.1

package/dist/tools/edit.js

@@ -1,235 +0,0 @@
-/**
- * Edit Tool
- * String replacement-based file editing (like Claude Code)
- * Requires exact matches for safety
- */
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { resolve, dirname } from 'path';
-// Undo stack (simple in-memory, could be persisted later)
-const undoStack = new Map();
-/**
- * View file content
- */
-export function viewFile(filepath, options = {}) {
-    const absPath = resolve(options.cwd || process.cwd(), filepath);
-    if (!existsSync(absPath)) {
-        return {
-            success: false,
-            filepath: absPath,
-            operation: 'view',
-            error: `File not found: ${absPath}`,
-        };
-    }
-    try {
-        const content = readFileSync(absPath, 'utf-8');
-        return {
-            success: true,
-            filepath: absPath,
-            operation: 'view',
-            content,
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            filepath: absPath,
-            operation: 'view',
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-/**
- * Create a new file
- */
-export function createFile(filepath, content, options = {}) {
-    const absPath = resolve(options.cwd || process.cwd(), filepath);
-    // Check if file exists
-    if (existsSync(absPath) && !options.createIfNotExists) {
-        return {
-            success: false,
-            filepath: absPath,
-            operation: 'create',
-            error: `File already exists: ${absPath}`,
-        };
-    }
-    try {
-        // Ensure directory exists
-        const dir = dirname(absPath);
-        if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true });
-        }
-        // Save to undo stack
-        if (existsSync(absPath)) {
-            const oldContent = readFileSync(absPath, 'utf-8');
-            if (!undoStack.has(absPath)) {
-                undoStack.set(absPath, []);
-            }
-            undoStack.get(absPath).push(oldContent);
-        }
-        // Write file
-        writeFileSync(absPath, content, 'utf-8');
-        return {
-            success: true,
-            filepath: absPath,
-            operation: 'create',
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            filepath: absPath,
-            operation: 'create',
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-/**
- * String replacement (exact match required)
- * CRITICAL: Must match exactly, or error if multiple matches
- */
-export function strReplace(filepath, oldString, newString, options = {}) {
-    const absPath = resolve(options.cwd || process.cwd(), filepath);
-    if (!existsSync(absPath)) {
-        return {
-            success: false,
-            filepath: absPath,
-            operation: 'str_replace',
-            error: `File not found: ${absPath}`,
-        };
-    }
-    try {
-        // Read file
-        const content = readFileSync(absPath, 'utf-8');
-        // Save to undo stack
-        if (!undoStack.has(absPath)) {
-            undoStack.set(absPath, []);
-        }
-        undoStack.get(absPath).push(content);
-        // Count matches
-        const matches = content.split(oldString).length - 1;
-        if (matches === 0) {
-            return {
-                success: false,
-                filepath: absPath,
-                operation: 'str_replace',
-                error: `String not found in file. Exact match required.`,
-            };
-        }
-        if (matches > 1) {
-            return {
-                success: false,
-                filepath: absPath,
-                operation: 'str_replace',
-                error: `Multiple matches found (${matches}). Provide more context to make the match unique.`,
-            };
-        }
-        // Perform replacement
-        const newContent = content.replace(oldString, newString);
-        // Write file
-        writeFileSync(absPath, newContent, 'utf-8');
-        return {
-            success: true,
-            filepath: absPath,
-            operation: 'str_replace',
-            replacements: 1,
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            filepath: absPath,
-            operation: 'str_replace',
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-/**
- * Undo last edit
- */
-export function undoEdit(filepath, options = {}) {
-    const absPath = resolve(options.cwd || process.cwd(), filepath);
-    const stack = undoStack.get(absPath);
-    if (!stack || stack.length === 0) {
-        return {
-            success: false,
-            filepath: absPath,
-            operation: 'undo',
-            error: 'No undo history available',
-        };
-    }
-    try {
-        const previousContent = stack.pop();
-        writeFileSync(absPath, previousContent, 'utf-8');
-        return {
-            success: true,
-            filepath: absPath,
-            operation: 'undo',
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            filepath: absPath,
-            operation: 'undo',
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-/**
- * Tool description for the model
- * This is critical - the model needs to understand how to use this tool
- */
-export const EDIT_TOOL_DESCRIPTION = `
-Edit Tool - String replacement-based file editing
-
-DESCRIPTION:
-Edit files using string replacement. Requires exact matches for safety.
-
-AVAILABLE OPERATIONS:
-1. **view(filepath)**: View file content
-2. **create(filepath, content)**: Create new file
-3. **str_replace(filepath, oldString, newString)**: Replace string in file
-4. **undo(filepath)**: Undo last edit
-
-CRITICAL RULES:
-1. **Exact Match Required**: oldString must match EXACTLY in the file
-2. **Unique Match Required**: If multiple matches found, provide more context
-3. **Absolute Paths**: All paths are resolved to absolute paths automatically
-4. **Context for Uniqueness**: Include surrounding lines if needed to make match unique
-
-STRING REPLACEMENT:
-- oldString must appear EXACTLY ONCE in the file
-- If 0 matches: Error - string not found
-- If 2+ matches: Error - provide more context
-- Include surrounding code/whitespace to ensure uniqueness
-
-EXAMPLES:
-- str_replace('/path/to/file.ts', 'function old()', 'function new()')
-- str_replace('/path/to/file.ts', 'const x = 1;\\n', 'const x = 2;\\n')
-- Include context: str_replace('/path/to/file.ts', '  // Comment\\n  function old()', '  // Comment\\n  function new()')
-
-PATH HANDLING:
-- All paths are resolved to absolute paths
-- Use absolute paths or paths relative to cwd
-- Example: '/Users/username/project/file.ts' (absolute)
-- Example: './file.ts' (relative to cwd)
-
-UNDO:
-- undo() restores file to previous state
-- Only one level of undo (last edit)
-- Undo stack is in-memory (lost on restart)
-
-ERROR HANDLING:
-- Check success field in result
-- Check error field for error message
-- Common errors:
-  - File not found
-  - String not found (0 matches)
-  - Multiple matches (need more context)
-
-SECURITY:
-- All paths are validated
-- No file system traversal beyond project directory
-- Exact match requirement prevents accidental replacements
-`;
-//# sourceMappingURL=edit.js.map

package/dist/tools/executor.js

@@ -1,153 +0,0 @@
-/**
- * Tool Executor
- * Execute tools with error handling and result formatting
- */
-import { getToolRegistry } from './registry.js';
-export class ToolExecutor {
-    /**
-     * Execute a single tool call
-     */
-    async execute(call) {
-        const startTime = Date.now();
-        const registry = getToolRegistry();
-        const tool = registry.get(call.tool);
-        // Import execution tracer dynamically to avoid circular dependencies
-        const { executionTracer } = await import('../infrastructure/observability/execution-tracer.js');
-        // Trace tool invocation
-        const traceId = executionTracer.trace({
-            operationType: 'tool_invocation',
-            operationName: call.tool,
-            input: { parameters: call.parameters },
-            metadata: {
-                toolId: call.id,
-            },
-        });
-        if (!tool) {
-            const duration = Date.now() - startTime;
-            executionTracer.trace({
-                operationType: 'tool_invocation',
-                operationName: call.tool,
-                error: new Error(`Tool not found: ${call.tool}`),
-                duration,
-                metadata: { toolId: call.id },
-            });
-            return {
-                success: false,
-                tool: call.tool,
-                error: `Tool not found: ${call.tool}`,
-                duration,
-            };
-        }
-        try {
-            // Validate parameters
-            const validation = validateParameters(call.parameters, tool.parameters);
-            if (!validation.valid) {
-                const duration = Date.now() - startTime;
-                const error = new Error(`Invalid parameters: ${validation.errors.join(', ')}`);
-                executionTracer.trace({
-                    operationType: 'tool_invocation',
-                    operationName: call.tool,
-                    error,
-                    duration,
-                    metadata: { toolId: call.id },
-                });
-                return {
-                    success: false,
-                    tool: call.tool,
-                    error: error.message,
-                    duration,
-                };
-            }
-            // Execute tool
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const result = await tool.execute(...Object.values(call.parameters));
-            const duration = Date.now() - startTime;
-            // Trace successful execution
-            executionTracer.trace({
-                operationType: 'tool_invocation',
-                operationName: call.tool,
-                output: {
-                    success: true,
-                    resultType: typeof result,
-                    resultSize: JSON.stringify(result).length,
-                },
-                duration,
-                metadata: { toolId: call.id },
-            });
-            return {
-                success: true,
-                tool: call.tool,
-                result,
-                duration,
-            };
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            const errorObj = error instanceof Error ? error : new Error(String(error));
-            executionTracer.trace({
-                operationType: 'tool_invocation',
-                operationName: call.tool,
-                error: errorObj,
-                duration,
-                metadata: { toolId: call.id },
-            });
-            return {
-                success: false,
-                tool: call.tool,
-                error: errorObj.message,
-                duration,
-            };
-        }
-    }
-    /**
-     * Execute multiple tool calls in sequence
-     * Stops on first error
-     */
-    async executeAll(calls) {
-        const results = [];
-        for (const call of calls) {
-            const result = await this.execute(call);
-            results.push(result);
-            if (!result.success) {
-                break;
-            }
-        }
-        return results;
-    }
-}
-/**
- * Validate parameters against schema
- */
-function validateParameters(params, schema) {
-    if (!schema) {
-        return { valid: true, errors: [] };
-    }
-    const errors = [];
-    // Check required parameters
-    for (const [key, def] of Object.entries(schema)) {
-        if (def.required && !(key in params)) {
-            errors.push(`Missing required parameter: ${key}`);
-        }
-    }
-    // Check parameter types
-    for (const [key, value] of Object.entries(params)) {
-        const def = schema[key];
-        if (def) {
-            const expectedType = def.type;
-            const actualType = typeof value;
-            if (expectedType === 'array') {
-                if (!Array.isArray(value)) {
-                    errors.push(`Parameter ${key} must be an array`);
-                }
-            }
-            else if (expectedType !== actualType && expectedType !== 'any') {
-                errors.push(`Parameter ${key} must be of type ${expectedType}, got ${actualType}`);
-            }
-        }
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-    };
-}
-//# sourceMappingURL=executor.js.map

package/dist/tools/git-tool.js

@@ -1,292 +0,0 @@
-/**
- * Tool: Git Operations
- * Provides Git-Context-Controller functionality
- * Integrates COMMIT, BRANCH, MERGE operations into reasoning loop
- *
- * Based on enterprise architecture: Git semantics in LLM reasoning
- */
-import { exec } from 'child_process';
-import { promisify } from 'util';
-const execAsync = promisify(exec);
-/**
- * Git Tool - Version Control Operations
- *
- * Available operations:
- * - COMMIT: Create checkpoint of changes
- * - BRANCH: Create/switch branches for exploration
- * - MERGE: Combine branches
- * - DIFF: Get changes between commits/branches
- * - LOG: Query commit history
- * - STATUS: Get current repository state
- */
-export class GitTool {
-    cwd;
-    constructor(cwd = process.cwd()) {
-        this.cwd = cwd;
-    }
-    /**
-     * COMMIT: Create checkpoint of current changes
-     */
-    async commit(message, files) {
-        try {
-            // Stage files if specified, otherwise stage all
-            if (files && files.length > 0) {
-                await execAsync(`git add ${files.join(' ')}`, { cwd: this.cwd });
-            }
-            else {
-                await execAsync('git add -A', { cwd: this.cwd });
-            }
-            // Create commit
-            const { stdout, stderr } = await execAsync(`git commit -m "${message.replace(/"/g, '\\"')}"`, { cwd: this.cwd });
-            return {
-                success: true,
-                output: stdout,
-                error: stderr || undefined,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                output: '',
-                error: error.message || String(error),
-            };
-        }
-    }
-    /**
-     * BRANCH: Create or switch to branch
-     */
-    async branch(name, create = false, switchTo = false) {
-        try {
-            if (create) {
-                const { stdout, stderr } = await execAsync(`git branch ${name}`, { cwd: this.cwd });
-                return {
-                    success: true,
-                    output: stdout,
-                    error: stderr || undefined,
-                };
-            }
-            if (switchTo) {
-                const { stdout, stderr } = await execAsync(`git checkout ${name}`, { cwd: this.cwd });
-                return {
-                    success: true,
-                    output: stdout,
-                    error: stderr || undefined,
-                };
-            }
-            // List branches
-            const { stdout } = await execAsync('git branch', { cwd: this.cwd });
-            return {
-                success: true,
-                output: stdout,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                output: '',
-                error: error.message || String(error),
-            };
-        }
-    }
-    /**
-     * MERGE: Combine branches
-     */
-    async merge(branch, strategy = 'merge') {
-        try {
-            let command;
-            if (strategy === 'rebase') {
-                command = `git rebase ${branch}`;
-            }
-            else if (strategy === 'squash') {
-                command = `git merge --squash ${branch}`;
-            }
-            else {
-                command = `git merge ${branch}`;
-            }
-            const { stdout, stderr } = await execAsync(command, { cwd: this.cwd });
-            return {
-                success: true,
-                output: stdout,
-                error: stderr || undefined,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                output: '',
-                error: error.message || String(error),
-            };
-        }
-    }
-    /**
-     * DIFF: Get changes between commits/branches/files
-     */
-    async diff(source, target, filepath) {
-        try {
-            let command = 'git diff';
-            if (source && target) {
-                command += ` ${source}..${target}`;
-            }
-            else if (source) {
-                command += ` ${source}`;
-            }
-            if (filepath) {
-                command += ` -- ${filepath}`;
-            }
-            const { stdout } = await execAsync(command, { cwd: this.cwd });
-            // Parse diff output
-            return this.parseDiff(stdout);
-        }
-        catch (error) {
-            return [];
-        }
-    }
-    /**
-     * LOG: Query commit history
-     */
-    async log(limit = 10, filepath) {
-        try {
-            let command = `git log -n ${limit} --pretty=format:"%H|%s|%an|%ad" --date=iso`;
-            if (filepath) {
-                command += ` -- ${filepath}`;
-            }
-            const { stdout } = await execAsync(command, { cwd: this.cwd });
-            const lines = stdout.split('\n').filter(l => l.trim());
-            return lines.map(line => {
-                const [hash, message, author, dateStr] = line.split('|');
-                return {
-                    hash: hash.substring(0, 8),
-                    message,
-                    author,
-                    date: new Date(dateStr),
-                    files: [], // Would need separate call to get files
-                };
-            });
-        }
-        catch (error) {
-            return [];
-        }
-    }
-    /**
-     * STATUS: Get current repository state
-     */
-    async status() {
-        try {
-            const { stdout } = await execAsync('git status --porcelain', { cwd: this.cwd });
-            const branchOutput = await execAsync('git branch --show-current', { cwd: this.cwd });
-            const branch = branchOutput.stdout.trim();
-            const modified = [];
-            const staged = [];
-            const untracked = [];
-            stdout.split('\n').forEach(line => {
-                if (!line.trim())
-                    return;
-                const status = line.substring(0, 2);
-                const filepath = line.substring(3);
-                if (status.startsWith('??')) {
-                    untracked.push(filepath);
-                }
-                else if (status.startsWith(' ')) {
-                    modified.push(filepath);
-                }
-                else {
-                    staged.push(filepath);
-                }
-            });
-            return { branch, modified, staged, untracked };
-        }
-        catch (error) {
-            return {
-                branch: 'unknown',
-                modified: [],
-                staged: [],
-                untracked: [],
-            };
-        }
-    }
-    /**
-     * Check if directory is a Git repository
-     */
-    async isRepository() {
-        try {
-            await execAsync('git rev-parse --git-dir', { cwd: this.cwd });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Parse diff output into structured format
-     */
-    parseDiff(diffOutput) {
-        const diffs = [];
-        const filePattern = /^diff --git a\/(.+?) b\/(.+?)$/gm;
-        let currentFile = null;
-        let currentDiff = '';
-        const lines = diffOutput.split('\n');
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const fileMatch = line.match(/^diff --git a\/(.+?) b\/(.+?)$/);
-            if (fileMatch) {
-                if (currentFile) {
-                    currentFile.diff = currentDiff;
-                    diffs.push(currentFile);
-                }
-                currentFile = {
-                    filepath: fileMatch[1],
-                    additions: 0,
-                    deletions: 0,
-                    diff: '',
-                };
-                currentDiff = line + '\n';
-            }
-            else if (currentFile) {
-                currentDiff += line + '\n';
-                if (line.startsWith('+') && !line.startsWith('+++')) {
-                    currentFile.additions++;
-                }
-                else if (line.startsWith('-') && !line.startsWith('---')) {
-                    currentFile.deletions++;
-                }
-            }
-        }
-        if (currentFile) {
-            currentFile.diff = currentDiff;
-            diffs.push(currentFile);
-        }
-        return diffs;
-    }
-}
-/**
- * Tool description for the model
- */
-export const GIT_TOOL_DESCRIPTION = `
-Git Tool - Version Control Operations (Git-Context-Controller)
-
-DESCRIPTION:
-Provides Git operations integrated into the reasoning loop. Enables the agent to
-create checkpoints (COMMIT), explore alternatives (BRANCH), combine changes (MERGE),
-and query history (LOG, DIFF) for structural reasoning about codebase changes.
-
-AVAILABLE OPERATIONS:
-- commit(message, files?): Create checkpoint of changes
-- branch(name, create?, switchTo?): Create or switch branches
-- merge(branch, strategy?): Combine branches (merge/rebase/squash)
-- diff(source?, target?, filepath?): Get changes between commits/branches
-- log(limit?, filepath?): Query commit history
-- status(): Get current repository state
-
-USE CASES:
-- Before major refactoring: Create branch for exploration
-- After successful changes: COMMIT to create checkpoint
-- When exploring alternatives: Use BRANCH to try different approaches
-- When debugging: Use DIFF to see what changed
-- When planning: Use LOG to understand project history
-
-INTEGRATION:
-These operations are integrated into the ReAct reasoning loop, allowing the agent
-to reason about codebase state over time and manage long-horizon tasks with
-version control semantics.
-`;
-//# sourceMappingURL=git-tool.js.map