@bluehawks/cli 1.0.0

package/src/core/tools/definitions/git.ts

@@ -0,0 +1,326 @@
+/**
+ * Bluehawks CLI - Git Tools
+ * Tools for Git operations
+ */
+
+import { simpleGit, type SimpleGit, type StatusResult } from 'simple-git';
+import { toolRegistry, type ToolHandler } from '../registry.js';
+
+function getGit(cwd?: string): SimpleGit {
+    return simpleGit(cwd || process.cwd());
+}
+
+const gitStatusTool: ToolHandler = {
+    name: 'git_status',
+    safeToAutoRun: true,
+    definition: {
+        type: 'function',
+        function: {
+            name: 'git_status',
+            description: 'Get the current Git status of the repository.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    cwd: {
+                        type: 'string',
+                        description: 'The working directory. Defaults to current directory.',
+                    },
+                },
+                required: [],
+            },
+        },
+    },
+    async execute(args) {
+        const cwd = args.cwd as string | undefined;
+        const git = getGit(cwd);
+
+        const status: StatusResult = await git.status();
+
+        const lines: string[] = [];
+        lines.push(`Branch: ${status.current || 'unknown'}`);
+        lines.push(`Tracking: ${status.tracking || 'none'}`);
+
+        if (status.ahead > 0) lines.push(`Ahead: ${status.ahead} commits`);
+        if (status.behind > 0) lines.push(`Behind: ${status.behind} commits`);
+
+        if (status.staged.length > 0) {
+            lines.push('\nStaged changes:');
+            status.staged.forEach((f) => lines.push(`  ✓ ${f}`));
+        }
+
+        if (status.modified.length > 0) {
+            lines.push('\nModified:');
+            status.modified.forEach((f) => lines.push(`  M ${f}`));
+        }
+
+        if (status.not_added.length > 0) {
+            lines.push('\nUntracked:');
+            status.not_added.forEach((f) => lines.push(`  ? ${f}`));
+        }
+
+        if (status.deleted.length > 0) {
+            lines.push('\nDeleted:');
+            status.deleted.forEach((f) => lines.push(`  D ${f}`));
+        }
+
+        if (
+            status.staged.length === 0 &&
+            status.modified.length === 0 &&
+            status.not_added.length === 0 &&
+            status.deleted.length === 0
+        ) {
+            lines.push('\nWorking tree clean');
+        }
+
+        return lines.join('\n');
+    },
+};
+
+const gitDiffTool: ToolHandler = {
+    name: 'git_diff',
+    safeToAutoRun: true,
+    definition: {
+        type: 'function',
+        function: {
+            name: 'git_diff',
+            description: 'Show git diff for the repository or specific files.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    files: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Optional list of files to show diff for.',
+                    },
+                    staged: {
+                        type: 'boolean',
+                        description: 'Show diff for staged changes. Default is false.',
+                    },
+                    cwd: {
+                        type: 'string',
+                        description: 'The working directory.',
+                    },
+                },
+                required: [],
+            },
+        },
+    },
+    async execute(args) {
+        const files = args.files as string[] | undefined;
+        const staged = (args.staged as boolean) ?? false;
+        const cwd = args.cwd as string | undefined;
+
+        const git = getGit(cwd);
+
+        const options = staged ? ['--staged'] : [];
+        if (files && files.length > 0) {
+            options.push('--', ...files);
+        }
+
+        const diff = await git.diff(options);
+
+        if (!diff.trim()) {
+            return staged ? 'No staged changes' : 'No changes';
+        }
+
+        return diff;
+    },
+};
+
+const gitLogTool: ToolHandler = {
+    name: 'git_log',
+    safeToAutoRun: true,
+    definition: {
+        type: 'function',
+        function: {
+            name: 'git_log',
+            description: 'Show git commit history.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    count: {
+                        type: 'number',
+                        description: 'Number of commits to show. Default is 10.',
+                    },
+                    file: {
+                        type: 'string',
+                        description: 'Show history for a specific file.',
+                    },
+                    cwd: {
+                        type: 'string',
+                        description: 'The working directory.',
+                    },
+                },
+                required: [],
+            },
+        },
+    },
+    async execute(args) {
+        const count = (args.count as number) || 10;
+        const file = args.file as string | undefined;
+        const cwd = args.cwd as string | undefined;
+
+        const git = getGit(cwd);
+
+        const options: string[] = [`-n`, `${count}`, '--oneline'];
+        if (file) {
+            options.push('--', file);
+        }
+
+        const log = await git.log(options);
+
+        if (!log.all || log.all.length === 0) {
+            return 'No commits found';
+        }
+
+        return log.all
+            .map((commit) => `${commit.hash.substring(0, 7)} ${commit.message}`)
+            .join('\n');
+    },
+};
+
+const gitCommitTool: ToolHandler = {
+    name: 'git_commit',
+    safeToAutoRun: false,
+    definition: {
+        type: 'function',
+        function: {
+            name: 'git_commit',
+            description: 'Create a Git commit with the staged changes.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    message: {
+                        type: 'string',
+                        description: 'The commit message.',
+                    },
+                    cwd: {
+                        type: 'string',
+                        description: 'The working directory.',
+                    },
+                },
+                required: ['message'],
+            },
+        },
+    },
+    async execute(args) {
+        const message = args.message as string;
+        const cwd = args.cwd as string | undefined;
+
+        const git = getGit(cwd);
+
+        const result = await git.commit(message);
+
+        return `Committed: ${result.commit || 'unknown'}\nSummary: ${result.summary.changes} files changed, ${result.summary.insertions} insertions, ${result.summary.deletions} deletions`;
+    },
+};
+
+const gitAddTool: ToolHandler = {
+    name: 'git_add',
+    safeToAutoRun: false,
+    definition: {
+        type: 'function',
+        function: {
+            name: 'git_add',
+            description: 'Stage files for commit.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    files: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Files to stage. Use ["."] to stage all changes.',
+                    },
+                    cwd: {
+                        type: 'string',
+                        description: 'The working directory.',
+                    },
+                },
+                required: ['files'],
+            },
+        },
+    },
+    async execute(args) {
+        const files = args.files as string[];
+        const cwd = args.cwd as string | undefined;
+
+        const git = getGit(cwd);
+
+        await git.add(files);
+
+        return `Staged: ${files.join(', ')}`;
+    },
+};
+
+const gitBranchTool: ToolHandler = {
+    name: 'git_branch',
+    safeToAutoRun: true,
+    definition: {
+        type: 'function',
+        function: {
+            name: 'git_branch',
+            description: 'List, create, or switch Git branches.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['list', 'create', 'switch', 'delete'],
+                        description: 'The action to perform. Default is "list".',
+                    },
+                    name: {
+                        type: 'string',
+                        description: 'Branch name (required for create, switch, delete).',
+                    },
+                    cwd: {
+                        type: 'string',
+                        description: 'The working directory.',
+                    },
+                },
+                required: [],
+            },
+        },
+    },
+    async execute(args) {
+        const action = (args.action as string) || 'list';
+        const name = args.name as string | undefined;
+        const cwd = args.cwd as string | undefined;
+
+        const git = getGit(cwd);
+
+        switch (action) {
+            case 'list': {
+                const branches = await git.branch();
+                return branches.all
+                    .map((b) => (b === branches.current ? `* ${b}` : `  ${b}`))
+                    .join('\n');
+            }
+            case 'create': {
+                if (!name) throw new Error('Branch name is required');
+                await git.checkoutLocalBranch(name);
+                return `Created and switched to branch: ${name}`;
+            }
+            case 'switch': {
+                if (!name) throw new Error('Branch name is required');
+                await git.checkout(name);
+                return `Switched to branch: ${name}`;
+            }
+            case 'delete': {
+                if (!name) throw new Error('Branch name is required');
+                await git.deleteLocalBranch(name);
+                return `Deleted branch: ${name}`;
+            }
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+    },
+};
+
+export function registerGitTools(): void {
+    toolRegistry.register(gitStatusTool);
+    toolRegistry.register(gitDiffTool);
+    toolRegistry.register(gitLogTool);
+    toolRegistry.register(gitCommitTool);
+    toolRegistry.register(gitAddTool);
+    toolRegistry.register(gitBranchTool);
+}

package/src/core/tools/definitions/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Bluehawks CLI - Tool Definitions Index
+ * Register all tools
+ */
+
+import { registerFileTools } from './file.js';
+import { registerShellTools } from './shell.js';
+import { registerSearchTools } from './search.js';
+import { registerGitTools } from './git.js';
+import { registerWebTools } from './web.js';
+
+export function registerAllTools(): void {
+    registerFileTools();
+    registerShellTools();
+    registerSearchTools();
+    registerGitTools();
+    registerWebTools();
+}
+
+export * from './file.js';
+export * from './shell.js';
+export * from './search.js';
+export * from './git.js';
+export * from './web.js';

package/src/core/tools/definitions/search.ts

@@ -0,0 +1,266 @@
+/**
+ * Bluehawks CLI - Search Tools
+ * Tools for searching files and code
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { toolRegistry, type ToolHandler } from '../registry.js';
+
+interface SearchMatch {
+    file: string;
+    line: number;
+    content: string;
+}
+
+async function searchInFile(
+    filePath: string,
+    pattern: RegExp,
+    maxMatches: number
+): Promise<SearchMatch[]> {
+    const matches: SearchMatch[] = [];
+
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const lines = content.split('\n');
+
+        for (let i = 0; i < lines.length && matches.length < maxMatches; i++) {
+            if (pattern.test(lines[i])) {
+                matches.push({
+                    file: filePath,
+                    line: i + 1,
+                    content: lines[i].trim().substring(0, 200),
+                });
+            }
+        }
+    } catch {
+        // Skip files that can't be read
+    }
+
+    return matches;
+}
+
+async function walkDirectory(
+    dir: string,
+    includes: string[],
+    excludes: string[],
+    maxDepth: number,
+    currentDepth = 0
+): Promise<string[]> {
+    if (currentDepth > maxDepth) return [];
+
+    const files: string[] = [];
+
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+
+            // Skip excluded patterns
+            if (excludes.some((ex) => entry.name === ex || entry.name.includes(ex))) {
+                continue;
+            }
+
+            if (entry.isDirectory()) {
+                const subFiles = await walkDirectory(fullPath, includes, excludes, maxDepth, currentDepth + 1);
+                files.push(...subFiles);
+            } else if (entry.isFile()) {
+                // Check includes
+                if (includes.length === 0 || includes.some((inc) => entry.name.endsWith(inc))) {
+                    files.push(fullPath);
+                }
+            }
+        }
+    } catch {
+        // Skip directories we can't read
+    }
+
+    return files;
+}
+
+const grepSearchTool: ToolHandler = {
+    name: 'grep_search',
+    safeToAutoRun: true,
+    definition: {
+        type: 'function',
+        function: {
+            name: 'grep_search',
+            description:
+                'Search for a pattern in files. Returns matching lines with file paths and line numbers.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: {
+                        type: 'string',
+                        description: 'The search pattern (regex supported).',
+                    },
+                    path: {
+                        type: 'string',
+                        description: 'The directory to search in. Defaults to current directory.',
+                    },
+                    includes: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'File extensions to include (e.g., [".ts", ".js"]).',
+                    },
+                    excludes: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Patterns to exclude (e.g., ["node_modules", ".git"]).',
+                    },
+                    case_insensitive: {
+                        type: 'boolean',
+                        description: 'Whether to perform case-insensitive search. Default is false.',
+                    },
+                    max_results: {
+                        type: 'number',
+                        description: 'Maximum number of results to return. Default is 50.',
+                    },
+                },
+                required: ['pattern'],
+            },
+        },
+    },
+    async execute(args) {
+        const patternStr = args.pattern as string;
+        const searchPath = (args.path as string) || process.cwd();
+        const includes = (args.includes as string[]) || [];
+        const excludes = (args.excludes as string[]) || ['node_modules', '.git', 'dist', 'build'];
+        const caseInsensitive = (args.case_insensitive as boolean) ?? false;
+        const maxResults = (args.max_results as number) || 50;
+
+        const absolutePath = path.resolve(process.cwd(), searchPath);
+        const flags = caseInsensitive ? 'gi' : 'g';
+        const pattern = new RegExp(patternStr, flags);
+
+        const files = await walkDirectory(absolutePath, includes, excludes, 10);
+        const allMatches: SearchMatch[] = [];
+
+        for (const file of files) {
+            if (allMatches.length >= maxResults) break;
+
+            const matches = await searchInFile(file, pattern, maxResults - allMatches.length);
+            for (const match of matches) {
+                allMatches.push({
+                    ...match,
+                    file: path.relative(process.cwd(), match.file),
+                });
+            }
+        }
+
+        if (allMatches.length === 0) {
+            return `No matches found for pattern: ${patternStr}`;
+        }
+
+        const output = allMatches
+            .map((m) => `${m.file}:${m.line}: ${m.content}`)
+            .join('\n');
+
+        return `Found ${allMatches.length} matches:\n\n${output}`;
+    },
+};
+
+const findFilesTool: ToolHandler = {
+    name: 'find_files',
+    safeToAutoRun: true,
+    definition: {
+        type: 'function',
+        function: {
+            name: 'find_files',
+            description: 'Find files by name or pattern in a directory.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: {
+                        type: 'string',
+                        description: 'The filename pattern to search for (supports wildcards like *.ts).',
+                    },
+                    path: {
+                        type: 'string',
+                        description: 'The directory to search in. Defaults to current directory.',
+                    },
+                    type: {
+                        type: 'string',
+                        enum: ['file', 'directory', 'any'],
+                        description: 'Type of entries to find. Default is "any".',
+                    },
+                    max_depth: {
+                        type: 'number',
+                        description: 'Maximum directory depth to search. Default is 10.',
+                    },
+                    max_results: {
+                        type: 'number',
+                        description: 'Maximum number of results. Default is 100.',
+                    },
+                },
+                required: ['pattern'],
+            },
+        },
+    },
+    async execute(args) {
+        const pattern = args.pattern as string;
+        const searchPath = (args.path as string) || process.cwd();
+        const type = (args.type as string) || 'any';
+        const maxDepth = (args.max_depth as number) || 10;
+        const maxResults = (args.max_results as number) || 100;
+
+        const absolutePath = path.resolve(process.cwd(), searchPath);
+        const results: string[] = [];
+
+        // Convert glob pattern to regex
+        const regexPattern = pattern
+            .replace(/\./g, '\\.')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.');
+        const regex = new RegExp(`^${regexPattern}$`, 'i');
+
+        async function search(dir: string, depth: number): Promise<void> {
+            if (depth > maxDepth || results.length >= maxResults) return;
+
+            try {
+                const entries = await fs.readdir(dir, { withFileTypes: true });
+
+                for (const entry of entries) {
+                    if (results.length >= maxResults) return;
+
+                    // Skip common excludes
+                    if (entry.name === 'node_modules' || entry.name === '.git') continue;
+
+                    const fullPath = path.join(dir, entry.name);
+                    const relativePath = path.relative(absolutePath, fullPath);
+
+                    const isMatch = regex.test(entry.name);
+                    const matchesType =
+                        type === 'any' ||
+                        (type === 'file' && entry.isFile()) ||
+                        (type === 'directory' && entry.isDirectory());
+
+                    if (isMatch && matchesType) {
+                        const prefix = entry.isDirectory() ? '📁 ' : '📄 ';
+                        results.push(prefix + relativePath);
+                    }
+
+                    if (entry.isDirectory()) {
+                        await search(fullPath, depth + 1);
+                    }
+                }
+            } catch {
+                // Skip directories we can't read
+            }
+        }
+
+        await search(absolutePath, 0);
+
+        if (results.length === 0) {
+            return `No files found matching pattern: ${pattern}`;
+        }
+
+        return `Found ${results.length} matches:\n\n${results.join('\n')}`;
+    },
+};
+
+export function registerSearchTools(): void {
+    toolRegistry.register(grepSearchTool);
+    toolRegistry.register(findFilesTool);
+}