@bluehawks/cli 1.0.0

package/src/core/session/storage.ts

@@ -0,0 +1,184 @@
+/**
+ * Bluehawks CLI - Session Storage
+ * Manages named sessions and session history
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+export interface StoredSession {
+    id: string;
+    name: string;
+    startTime: string;
+    lastAccessTime: string;
+    projectPath: string;
+    model: string;
+    messageCount: number;
+    preview: string;
+}
+
+export interface SessionIndex {
+    lastSessionId: string | null;
+    sessions: Record<string, StoredSession>;
+}
+
+const SESSIONS_DIR = path.join(os.homedir(), '.bluehawks', 'sessions');
+const INDEX_FILE = 'index.json';
+
+export class SessionStorage {
+    private indexPath: string;
+    private sessionsDir: string;
+
+    constructor() {
+        this.sessionsDir = SESSIONS_DIR;
+        this.indexPath = path.join(SESSIONS_DIR, INDEX_FILE);
+    }
+
+    async ensureDir(): Promise<void> {
+        await fs.mkdir(this.sessionsDir, { recursive: true });
+    }
+
+    async getIndex(): Promise<SessionIndex> {
+        try {
+            const content = await fs.readFile(this.indexPath, 'utf-8');
+            return JSON.parse(content);
+        } catch {
+            return { lastSessionId: null, sessions: {} };
+        }
+    }
+
+    async saveIndex(index: SessionIndex): Promise<void> {
+        await this.ensureDir();
+        await fs.writeFile(this.indexPath, JSON.stringify(index, null, 2));
+    }
+
+    async saveSession(
+        sessionId: string,
+        name: string | null,
+        data: unknown,
+        metadata: { projectPath: string; model: string; messageCount: number; preview: string }
+    ): Promise<void> {
+        await this.ensureDir();
+
+        // Save session data
+        const sessionFile = path.join(this.sessionsDir, `${sessionId}.json`);
+        await fs.writeFile(sessionFile, JSON.stringify(data, null, 2));
+
+        // Update index
+        const index = await this.getIndex();
+        const storedSession: StoredSession = {
+            id: sessionId,
+            name: name || sessionId,
+            startTime: index.sessions[sessionId]?.startTime || new Date().toISOString(),
+            lastAccessTime: new Date().toISOString(),
+            projectPath: metadata.projectPath,
+            model: metadata.model,
+            messageCount: metadata.messageCount,
+            preview: metadata.preview,
+        };
+
+        index.sessions[sessionId] = storedSession;
+        index.lastSessionId = sessionId;
+        await this.saveIndex(index);
+    }
+
+    async loadSession(sessionIdOrName: string): Promise<unknown | null> {
+        const index = await this.getIndex();
+
+        // Try to find by ID first
+        let sessionId = sessionIdOrName;
+
+        // If not found by ID, search by name
+        if (!index.sessions[sessionIdOrName]) {
+            const found = Object.values(index.sessions).find(
+                (s) => s.name.toLowerCase() === sessionIdOrName.toLowerCase()
+            );
+            if (found) {
+                sessionId = found.id;
+            } else {
+                return null;
+            }
+        }
+
+        try {
+            const sessionFile = path.join(this.sessionsDir, `${sessionId}.json`);
+            const content = await fs.readFile(sessionFile, 'utf-8');
+            return JSON.parse(content);
+        } catch {
+            return null;
+        }
+    }
+
+    async loadLastSession(): Promise<{ id: string; data: unknown } | null> {
+        const index = await this.getIndex();
+        if (!index.lastSessionId) {
+            return null;
+        }
+
+        const data = await this.loadSession(index.lastSessionId);
+        return data ? { id: index.lastSessionId, data } : null;
+    }
+
+    async listSessions(limit = 10): Promise<StoredSession[]> {
+        const index = await this.getIndex();
+        return Object.values(index.sessions)
+            .sort((a, b) => new Date(b.lastAccessTime).getTime() - new Date(a.lastAccessTime).getTime())
+            .slice(0, limit);
+    }
+
+    async deleteSession(sessionIdOrName: string): Promise<boolean> {
+        const index = await this.getIndex();
+
+        let sessionId = sessionIdOrName;
+        if (!index.sessions[sessionIdOrName]) {
+            const found = Object.values(index.sessions).find(
+                (s) => s.name.toLowerCase() === sessionIdOrName.toLowerCase()
+            );
+            if (found) {
+                sessionId = found.id;
+            } else {
+                return false;
+            }
+        }
+
+        try {
+            const sessionFile = path.join(this.sessionsDir, `${sessionId}.json`);
+            await fs.unlink(sessionFile);
+            delete index.sessions[sessionId];
+            if (index.lastSessionId === sessionId) {
+                index.lastSessionId = null;
+            }
+            await this.saveIndex(index);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    async renameSession(sessionIdOrName: string, newName: string): Promise<boolean> {
+        const index = await this.getIndex();
+
+        let sessionId = sessionIdOrName;
+        if (!index.sessions[sessionIdOrName]) {
+            const found = Object.values(index.sessions).find(
+                (s) => s.name.toLowerCase() === sessionIdOrName.toLowerCase()
+            );
+            if (found) {
+                sessionId = found.id;
+            } else {
+                return false;
+            }
+        }
+
+        if (index.sessions[sessionId]) {
+            index.sessions[sessionId].name = newName;
+            await this.saveIndex(index);
+            return true;
+        }
+
+        return false;
+    }
+}
+
+export const sessionStorage = new SessionStorage();

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

@@ -0,0 +1,312 @@
+/**
+ * Bluehawks CLI - File System Tools
+ * Tools for reading, writing, and editing files
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { toolRegistry, type ToolHandler } from '../registry.js';
+import { MAX_FILE_SIZE_BYTES } from '../../../config/constants.js';
+
+// Read File Tool
+const readFileTool: ToolHandler = {
+    name: 'read_file',
+    safeToAutoRun: true,
+    definition: {
+        type: 'function',
+        function: {
+            name: 'read_file',
+            description:
+                'Read the contents of a file. Use this to understand code, configuration, or any text file.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'The absolute or relative path to the file to read.',
+                    },
+                    start_line: {
+                        type: 'number',
+                        description: 'Optional. The starting line number (1-indexed) to read from.',
+                    },
+                    end_line: {
+                        type: 'number',
+                        description: 'Optional. The ending line number (1-indexed) to read to.',
+                    },
+                },
+                required: ['path'],
+            },
+        },
+    },
+    async execute(args) {
+        const filePath = args.path as string;
+        const startLine = args.start_line as number | undefined;
+        const endLine = args.end_line as number | undefined;
+
+        const absolutePath = path.resolve(process.cwd(), filePath);
+
+        // Check if file exists
+        try {
+            await fs.access(absolutePath);
+        } catch {
+            throw new Error(`File not found: ${filePath}`);
+        }
+
+        // Check file size
+        const stats = await fs.stat(absolutePath);
+        if (stats.size > MAX_FILE_SIZE_BYTES) {
+            throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES})`);
+        }
+
+        let content = await fs.readFile(absolutePath, 'utf-8');
+
+        // Handle line range if specified
+        if (startLine !== undefined || endLine !== undefined) {
+            const lines = content.split('\n');
+            const start = Math.max(1, startLine || 1) - 1;
+            const end = Math.min(lines.length, endLine || lines.length);
+            content = lines.slice(start, end).join('\n');
+        }
+
+        return content;
+    },
+};
+
+// Write File Tool
+const writeFileTool: ToolHandler = {
+    name: 'write_file',
+    safeToAutoRun: false,
+    definition: {
+        type: 'function',
+        function: {
+            name: 'write_file',
+            description:
+                'Write content to a file. Creates the file if it does not exist, or overwrites if it does.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'The absolute or relative path to the file to write.',
+                    },
+                    content: {
+                        type: 'string',
+                        description: 'The content to write to the file.',
+                    },
+                },
+                required: ['path', 'content'],
+            },
+        },
+    },
+    async execute(args) {
+        const filePath = args.path as string;
+        const content = args.content as string;
+
+        const absolutePath = path.resolve(process.cwd(), filePath);
+
+        // Create directory if it doesn't exist
+        const dir = path.dirname(absolutePath);
+        await fs.mkdir(dir, { recursive: true });
+
+        await fs.writeFile(absolutePath, content, 'utf-8');
+
+        return `Successfully wrote ${content.length} characters to ${filePath}`;
+    },
+};
+
+// Edit File Tool
+const editFileTool: ToolHandler = {
+    name: 'edit_file',
+    safeToAutoRun: false,
+    definition: {
+        type: 'function',
+        function: {
+            name: 'edit_file',
+            description:
+                'Edit a file by replacing specific content. Use this to make targeted changes to existing files.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'The absolute or relative path to the file to edit.',
+                    },
+                    old_content: {
+                        type: 'string',
+                        description: 'The exact content to find and replace.',
+                    },
+                    new_content: {
+                        type: 'string',
+                        description: 'The new content to replace with.',
+                    },
+                },
+                required: ['path', 'old_content', 'new_content'],
+            },
+        },
+    },
+    async execute(args) {
+        const filePath = args.path as string;
+        const oldContent = args.old_content as string;
+        const newContent = args.new_content as string;
+
+        const absolutePath = path.resolve(process.cwd(), filePath);
+
+        // Read current content
+        const content = await fs.readFile(absolutePath, 'utf-8');
+
+        // Check if old content exists
+        if (!content.includes(oldContent)) {
+            throw new Error(`Could not find the specified content to replace in ${filePath}`);
+        }
+
+        // Replace content
+        const newFileContent = content.replace(oldContent, newContent);
+
+        // Write back
+        await fs.writeFile(absolutePath, newFileContent, 'utf-8');
+
+        return `Successfully edited ${filePath}`;
+    },
+};
+
+// List Directory Tool
+const listDirTool: ToolHandler = {
+    name: 'list_directory',
+    safeToAutoRun: true,
+    definition: {
+        type: 'function',
+        function: {
+            name: 'list_directory',
+            description: 'List the contents of a directory, including files and subdirectories.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'The absolute or relative path to the directory to list.',
+                    },
+                    recursive: {
+                        type: 'boolean',
+                        description: 'Whether to list recursively. Default is false.',
+                    },
+                    max_depth: {
+                        type: 'number',
+                        description: 'Maximum depth to recurse. Default is 3.',
+                    },
+                },
+                required: ['path'],
+            },
+        },
+    },
+    async execute(args) {
+        const dirPath = args.path as string;
+        const recursive = (args.recursive as boolean) ?? false;
+        const maxDepth = (args.max_depth as number) ?? 3;
+
+        const absolutePath = path.resolve(process.cwd(), dirPath);
+
+        async function listDir(dir: string, depth: number): Promise<string[]> {
+            if (depth > maxDepth) return [];
+
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            const results: string[] = [];
+
+            for (const entry of entries) {
+                // Skip hidden files and common excludes
+                if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+
+                const relativePath = path.relative(absolutePath, path.join(dir, entry.name));
+                const prefix = entry.isDirectory() ? '📁 ' : '📄 ';
+                results.push(prefix + relativePath);
+
+                if (recursive && entry.isDirectory()) {
+                    const subEntries = await listDir(path.join(dir, entry.name), depth + 1);
+                    results.push(...subEntries);
+                }
+            }
+
+            return results;
+        }
+
+        const entries = await listDir(absolutePath, 0);
+        return entries.length > 0 ? entries.join('\n') : 'Directory is empty';
+    },
+};
+
+// Create Directory Tool
+const createDirTool: ToolHandler = {
+    name: 'create_directory',
+    safeToAutoRun: false,
+    definition: {
+        type: 'function',
+        function: {
+            name: 'create_directory',
+            description: 'Create a new directory, including any necessary parent directories.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'The absolute or relative path of the directory to create.',
+                    },
+                },
+                required: ['path'],
+            },
+        },
+    },
+    async execute(args) {
+        const dirPath = args.path as string;
+        const absolutePath = path.resolve(process.cwd(), dirPath);
+
+        await fs.mkdir(absolutePath, { recursive: true });
+
+        return `Successfully created directory: ${dirPath}`;
+    },
+};
+
+// Delete File Tool
+const deleteFileTool: ToolHandler = {
+    name: 'delete_file',
+    safeToAutoRun: false,
+    definition: {
+        type: 'function',
+        function: {
+            name: 'delete_file',
+            description: 'Delete a file or directory.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'The absolute or relative path to delete.',
+                    },
+                    recursive: {
+                        type: 'boolean',
+                        description: 'If true, recursively delete directories. Default is false.',
+                    },
+                },
+                required: ['path'],
+            },
+        },
+    },
+    async execute(args) {
+        const filePath = args.path as string;
+        const recursive = (args.recursive as boolean) ?? false;
+
+        const absolutePath = path.resolve(process.cwd(), filePath);
+
+        await fs.rm(absolutePath, { recursive, force: false });
+
+        return `Successfully deleted: ${filePath}`;
+    },
+};
+
+// Register all file tools
+export function registerFileTools(): void {
+    toolRegistry.register(readFileTool);
+    toolRegistry.register(writeFileTool);
+    toolRegistry.register(editFileTool);
+    toolRegistry.register(listDirTool);
+    toolRegistry.register(createDirTool);
+    toolRegistry.register(deleteFileTool);
+}