neuro-cli 4.1.0

package/dist/tools/index.d.ts

@@ -0,0 +1,9 @@
+import { ToolRegistry } from './registry.js';
+export declare function registerAllTools(registry?: ToolRegistry): ToolRegistry;
+export { globalRegistry } from './registry.js';
+export { fileTools } from './file.js';
+export { shellTools } from './bash.js';
+export { webTools } from './web.js';
+export { memoryTools } from './memory.js';
+export { extendedTools } from './extended.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -0,0 +1,40 @@
+// ============================================================
+// NeuroCLI - Tool Registration
+// Registers all built-in tools (15+ tools)
+// ============================================================
+import { globalRegistry } from './registry.js';
+import { fileTools } from './file.js';
+import { shellTools } from './bash.js';
+import { webTools } from './web.js';
+import { memoryTools } from './memory.js';
+import { extendedTools } from './extended.js';
+export function registerAllTools(registry = globalRegistry) {
+    // Register file tools (7)
+    for (const tool of fileTools) {
+        registry.register(tool);
+    }
+    // Register shell/bash tools (2)
+    for (const tool of shellTools) {
+        registry.register(tool);
+    }
+    // Register web tools (3)
+    for (const tool of webTools) {
+        registry.register(tool);
+    }
+    // Register memory/knowledge tools (3)
+    for (const tool of memoryTools) {
+        registry.register(tool);
+    }
+    // Register extended tools: Todo, AskUser, Monitor (3)
+    for (const tool of extendedTools) {
+        registry.register(tool);
+    }
+    return registry;
+}
+export { globalRegistry } from './registry.js';
+export { fileTools } from './file.js';
+export { shellTools } from './bash.js';
+export { webTools } from './web.js';
+export { memoryTools } from './memory.js';
+export { extendedTools } from './extended.js';
+//# sourceMappingURL=index.js.map

package/dist/tools/memory.d.ts

@@ -0,0 +1,6 @@
+import { ToolExecutor } from './registry.js';
+export declare const saveMemoryTool: ToolExecutor;
+export declare const recallMemoryTool: ToolExecutor;
+export declare const projectContextTool: ToolExecutor;
+export declare const memoryTools: ToolExecutor[];
+//# sourceMappingURL=memory.d.ts.map

package/dist/tools/memory.js

@@ -0,0 +1,197 @@
+// ============================================================
+// NeuroCLI - Memory & Knowledge Tools
+// Persistent memory for cross-session learning
+// ============================================================
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const MEMORY_DIR = join(homedir(), '.neuro', 'memory');
+function loadMemory() {
+    const memFile = join(MEMORY_DIR, 'store.json');
+    if (existsSync(memFile)) {
+        try {
+            return JSON.parse(readFileSync(memFile, 'utf-8'));
+        }
+        catch {
+            return { entries: {} };
+        }
+    }
+    return { entries: {} };
+}
+function saveMemory(store) {
+    if (!existsSync(MEMORY_DIR)) {
+        mkdirSync(MEMORY_DIR, { recursive: true });
+    }
+    writeFileSync(join(MEMORY_DIR, 'store.json'), JSON.stringify(store, null, 2), 'utf-8');
+}
+// ---- Save Memory ----
+const saveMemoryDef = {
+    name: 'save_memory',
+    description: 'Save important information to persistent memory. Information persists across sessions. Use for project conventions, user preferences, API patterns, etc.',
+    parameters: {
+        type: 'object',
+        properties: {
+            key: { type: 'string', description: 'Unique key for this memory entry' },
+            value: { type: 'string', description: 'The information to save' },
+            tags: { type: 'string', description: 'Comma-separated tags for categorization' },
+        },
+        required: ['key', 'value'],
+    },
+};
+export const saveMemoryTool = {
+    name: 'save_memory',
+    definition: saveMemoryDef,
+    risk: 'low',
+    async execute(args) {
+        const store = loadMemory();
+        const key = args.key;
+        const tags = (args.tags || '').split(',').map(t => t.trim()).filter(Boolean);
+        const now = Date.now();
+        if (store.entries[key]) {
+            store.entries[key].value = args.value;
+            store.entries[key].tags = tags;
+            store.entries[key].updatedAt = now;
+            store.entries[key].accessCount++;
+        }
+        else {
+            store.entries[key] = {
+                key,
+                value: args.value,
+                tags,
+                createdAt: now,
+                updatedAt: now,
+                accessCount: 1,
+            };
+        }
+        saveMemory(store);
+        return `Memory saved: "${key}" (${args.value.length} chars, ${tags.length} tags)`;
+    },
+};
+// ---- Recall Memory ----
+const recallMemoryDef = {
+    name: 'recall_memory',
+    description: 'Recall information from persistent memory. Search by key or tags.',
+    parameters: {
+        type: 'object',
+        properties: {
+            key: { type: 'string', description: 'Exact key to recall' },
+            tag: { type: 'string', description: 'Tag to search for' },
+            query: { type: 'string', description: 'Free-text search across all memories' },
+        },
+        required: [],
+    },
+};
+export const recallMemoryTool = {
+    name: 'recall_memory',
+    definition: recallMemoryDef,
+    risk: 'low',
+    async execute(args) {
+        const store = loadMemory();
+        const entries = Object.values(store.entries);
+        if (entries.length === 0)
+            return 'No memories stored yet.';
+        let results = [];
+        if (args.key) {
+            const entry = store.entries[args.key];
+            if (entry) {
+                entry.accessCount++;
+                saveMemory(store);
+                return `Memory: "${entry.key}"\n${entry.value}\nTags: ${entry.tags.join(', ')}\nCreated: ${new Date(entry.createdAt).toISOString()}`;
+            }
+            return `No memory found with key: "${args.key}"`;
+        }
+        if (args.tag) {
+            const tag = args.tag.toLowerCase();
+            results = entries.filter(e => e.tags.some(t => t.toLowerCase().includes(tag)));
+        }
+        if (args.query) {
+            const query = args.query.toLowerCase();
+            results = entries.filter(e => e.key.toLowerCase().includes(query) ||
+                e.value.toLowerCase().includes(query) ||
+                e.tags.some(t => t.toLowerCase().includes(query)));
+        }
+        if (!args.key && !args.tag && !args.query) {
+            results = entries;
+        }
+        if (results.length === 0)
+            return 'No matching memories found.';
+        return results.map(e => `📝 "${e.key}" [${e.tags.join(', ')}]\n   ${e.value.slice(0, 200)}${e.value.length > 200 ? '...' : ''}\n   Last updated: ${new Date(e.updatedAt).toISOString()}`).join('\n\n');
+    },
+};
+// ---- Project Context ----
+const projectContextDef = {
+    name: 'project_context',
+    description: 'Gather context about the current project: tech stack, dependencies, structure, git status.',
+    parameters: {
+        type: 'object',
+        properties: {
+            depth: { type: 'string', description: 'How much context to gather', enum: ['quick', 'standard', 'deep'] },
+        },
+        required: [],
+    },
+};
+export const projectContextTool = {
+    name: 'project_context',
+    definition: projectContextDef,
+    risk: 'low',
+    async execute(args, context) {
+        const depth = args.depth || 'standard';
+        const lines = [];
+        lines.push(`📂 Working Directory: ${context.workingDirectory}`);
+        // Check for common project files
+        const projectFiles = [
+            'package.json', 'tsconfig.json', 'Cargo.toml', 'pyproject.toml',
+            'go.mod', 'pom.xml', 'build.gradle', 'Makefile', 'Dockerfile',
+            'docker-compose.yml', '.env.example', 'README.md',
+        ];
+        const found = [];
+        for (const file of projectFiles) {
+            if (existsSync(join(context.workingDirectory, file))) {
+                found.push(file);
+            }
+        }
+        lines.push(`\n📋 Project Files: ${found.join(', ') || 'none detected'}`);
+        // Parse package.json if exists
+        const pkgPath = join(context.workingDirectory, 'package.json');
+        if (existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+                lines.push(`\n📦 Name: ${pkg.name || 'unnamed'}`);
+                lines.push(`📦 Version: ${pkg.version || '0.0.0'}`);
+                if (pkg.dependencies) {
+                    const deps = Object.keys(pkg.dependencies);
+                    lines.push(`📦 Dependencies: ${deps.join(', ')}`);
+                }
+                if (pkg.devDependencies) {
+                    const devDeps = Object.keys(pkg.devDependencies);
+                    lines.push(`📦 Dev Dependencies: ${devDeps.join(', ')}`);
+                }
+            }
+            catch { }
+        }
+        // Parse pyproject.toml if exists
+        const pyPath = join(context.workingDirectory, 'pyproject.toml');
+        if (existsSync(pyPath)) {
+            try {
+                const content = readFileSync(pyPath, 'utf-8');
+                const nameMatch = content.match(/name\s*=\s*"([^"]+)"/);
+                if (nameMatch)
+                    lines.push(`🐍 Python Project: ${nameMatch[1]}`);
+            }
+            catch { }
+        }
+        // Git info
+        try {
+            const { execSync } = await import('child_process');
+            const branch = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8', cwd: context.workingDirectory }).trim();
+            lines.push(`\n🌿 Git Branch: ${branch}`);
+            const status = execSync('git status --short', { encoding: 'utf-8', cwd: context.workingDirectory }).trim();
+            const changedFiles = status ? status.split('\n').length : 0;
+            lines.push(`🌿 Changed Files: ${changedFiles}`);
+        }
+        catch { }
+        return lines.join('\n');
+    },
+};
+export const memoryTools = [saveMemoryTool, recallMemoryTool, projectContextTool];
+//# sourceMappingURL=memory.js.map

package/dist/tools/registry.d.ts

@@ -0,0 +1,29 @@
+import { ToolDefinition, ToolResult, ApprovalRequest } from '../core/types.js';
+export interface ToolExecutor {
+    name: string;
+    definition?: ToolDefinition;
+    description?: string;
+    parameters?: ToolDefinition['parameters'];
+    execute: (args: Record<string, unknown>, context: ToolContext) => Promise<string>;
+    getApprovalRequest?: (args: Record<string, unknown>) => ApprovalRequest;
+    risk: 'low' | 'medium' | 'high';
+}
+export interface ToolContext {
+    workingDirectory: string;
+    sessionId: string;
+    agentName: string;
+    onProgress?: (message: string) => void;
+}
+export declare class ToolRegistry {
+    private tools;
+    register(tool: ToolExecutor): void;
+    unregister(name: string): void;
+    get(name: string): ToolExecutor | undefined;
+    getAll(): ToolExecutor[];
+    getDefinitions(toolNames?: string[]): ToolDefinition[];
+    execute(name: string, args: Record<string, unknown>, context: ToolContext): Promise<ToolResult>;
+    getApprovalRequest(name: string, args: Record<string, unknown>): ApprovalRequest | null;
+    has(name: string): boolean;
+}
+export declare const globalRegistry: ToolRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/dist/tools/registry.js

@@ -0,0 +1,64 @@
+// ============================================================
+// NeuroCLI - Tool Registry
+// Central tool management and execution system
+// ============================================================
+export class ToolRegistry {
+    tools = new Map();
+    register(tool) {
+        this.tools.set(tool.name, tool);
+    }
+    unregister(name) {
+        this.tools.delete(name);
+    }
+    get(name) {
+        return this.tools.get(name);
+    }
+    getAll() {
+        return Array.from(this.tools.values());
+    }
+    getDefinitions(toolNames) {
+        if (toolNames) {
+            return toolNames
+                .map(name => this.tools.get(name)?.definition)
+                .filter((d) => d !== undefined);
+        }
+        return this.getAll().map(t => t.definition).filter((d) => d !== undefined);
+    }
+    async execute(name, args, context) {
+        const tool = this.tools.get(name);
+        if (!tool) {
+            return {
+                toolCallId: `error_${Date.now()}`,
+                content: `Unknown tool: ${name}`,
+                isError: true,
+            };
+        }
+        try {
+            const content = await tool.execute(args, context);
+            return {
+                toolCallId: `tool_${Date.now()}`,
+                content,
+                isError: false,
+            };
+        }
+        catch (error) {
+            return {
+                toolCallId: `error_${Date.now()}`,
+                content: `Tool execution error (${name}): ${error instanceof Error ? error.message : String(error)}`,
+                isError: true,
+            };
+        }
+    }
+    getApprovalRequest(name, args) {
+        const tool = this.tools.get(name);
+        if (!tool || !tool.getApprovalRequest)
+            return null;
+        return tool.getApprovalRequest(args);
+    }
+    has(name) {
+        return this.tools.has(name);
+    }
+}
+// Global singleton
+export const globalRegistry = new ToolRegistry();
+//# sourceMappingURL=registry.js.map

package/dist/tools/web.d.ts

@@ -0,0 +1,6 @@
+import { ToolExecutor } from './registry.js';
+export declare const webSearchTool: ToolExecutor;
+export declare const webFetchTool: ToolExecutor;
+export declare const docSearchTool: ToolExecutor;
+export declare const webTools: ToolExecutor[];
+//# sourceMappingURL=web.d.ts.map

package/dist/tools/web.js

@@ -0,0 +1,150 @@
+// ============================================================
+// NeuroCLI - Web Tools
+// Web search and fetch capabilities
+// ============================================================
+const MAX_FETCH_SIZE = 500 * 1024; // 500KB
+const FETCH_TIMEOUT = 30000;
+function truncateWebContent(content, maxLength = 30000) {
+    if (content.length <= maxLength)
+        return content;
+    const half = Math.floor(maxLength / 2);
+    return content.slice(0, half) + '\n\n... [content truncated] ...\n\n' + content.slice(-half);
+}
+// ---- Web Search ----
+const webSearchDef = {
+    name: 'web_search',
+    description: 'Search the web for information. Returns search results with titles, URLs, and descriptions.',
+    parameters: {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Search query' },
+            max_results: { type: 'number', description: 'Maximum number of results (default: 10)' },
+        },
+        required: ['query'],
+    },
+};
+export const webSearchTool = {
+    name: 'web_search',
+    definition: webSearchDef,
+    risk: 'low',
+    async execute(args) {
+        const query = args.query;
+        const maxResults = args.max_results || 10;
+        try {
+            // Use SearXNG or DuckDuckGo as search backend
+            const url = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_html=1&max_results=${maxResults}`;
+            const response = await fetch(url, {
+                headers: { 'User-Agent': 'NeuroCLI/1.0' },
+                signal: AbortSignal.timeout(FETCH_TIMEOUT),
+            });
+            const data = await response.json();
+            const results = [];
+            if (data.Abstract) {
+                results.push(`📖 Summary: ${data.Abstract}\nSource: ${data.AbstractURL || 'DuckDuckGo'}\n`);
+            }
+            if (data.RelatedTopics) {
+                for (const topic of data.RelatedTopics.slice(0, maxResults)) {
+                    if (topic.Text && topic.FirstURL) {
+                        results.push(`🔗 ${topic.Text}\n   URL: ${topic.FirstURL}`);
+                    }
+                }
+            }
+            if (results.length === 0) {
+                // Fallback: try a different approach
+                return `Search results for "${query}":\n\nNo structured results found. Try using web_fetch to access specific URLs directly.`;
+            }
+            return `Search results for "${query}":\n\n${results.join('\n\n')}`;
+        }
+        catch (error) {
+            return `Search error: ${error.message}. Try using web_fetch with a specific URL instead.`;
+        }
+    },
+};
+// ---- Web Fetch ----
+const webFetchDef = {
+    name: 'web_fetch',
+    description: 'Fetch and extract text content from a web page URL. Returns the page text content.',
+    parameters: {
+        type: 'object',
+        properties: {
+            url: { type: 'string', description: 'URL to fetch' },
+            selector: { type: 'string', description: 'CSS selector to extract specific content (optional)' },
+            raw: { type: 'boolean', description: 'Return raw HTML instead of text (default: false)' },
+        },
+        required: ['url'],
+    },
+};
+export const webFetchTool = {
+    name: 'web_fetch',
+    definition: webFetchDef,
+    risk: 'low',
+    async execute(args) {
+        const url = args.url;
+        const raw = args.raw || false;
+        try {
+            const response = await fetch(url, {
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (compatible; NeuroCLI/1.0)',
+                    'Accept': raw ? 'text/html' : 'text/html,application/xhtml+xml',
+                },
+                signal: AbortSignal.timeout(FETCH_TIMEOUT),
+            });
+            if (!response.ok) {
+                return `Error fetching ${url}: HTTP ${response.status} ${response.statusText}`;
+            }
+            let content = await response.text();
+            if (content.length > MAX_FETCH_SIZE) {
+                content = content.slice(0, MAX_FETCH_SIZE) + '\n\n... [content too large, truncated]';
+            }
+            if (!raw) {
+                // Basic HTML to text conversion
+                content = content
+                    .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+                    .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+                    .replace(/<nav[^>]*>[\s\S]*?<\/nav>/gi, '')
+                    .replace(/<footer[^>]*>[\s\S]*?<\/footer>/gi, '')
+                    .replace(/<header[^>]*>[\s\S]*?<\/header>/gi, '')
+                    .replace(/<[^>]+>/g, ' ')
+                    .replace(/&nbsp;/g, ' ')
+                    .replace(/&amp;/g, '&')
+                    .replace(/&lt;/g, '<')
+                    .replace(/&gt;/g, '>')
+                    .replace(/&quot;/g, '"')
+                    .replace(/&#39;/g, "'")
+                    .replace(/\s+/g, ' ')
+                    .trim();
+            }
+            return truncateWebContent(`Fetched: ${url}\n\n${content}`);
+        }
+        catch (error) {
+            return `Error fetching ${url}: ${error.message}`;
+        }
+    },
+};
+// ---- Documentation Search ----
+const docSearchDef = {
+    name: 'doc_search',
+    description: 'Search documentation for a specific library, framework, or API. Returns relevant documentation snippets.',
+    parameters: {
+        type: 'object',
+        properties: {
+            library: { type: 'string', description: 'Library or framework name (e.g., "react", "next.js", "python")' },
+            query: { type: 'string', description: 'Specific question or topic to search for' },
+        },
+        required: ['library', 'query'],
+    },
+};
+export const docSearchTool = {
+    name: 'doc_search',
+    definition: docSearchDef,
+    risk: 'low',
+    async execute(args) {
+        const library = args.library;
+        const query = args.query;
+        const searchQuery = `${library} ${query} documentation`;
+        // Delegate to web search with documentation-focused query
+        return webSearchTool.execute({ query: searchQuery, max_results: 5 }, {});
+    },
+};
+export const webTools = [webSearchTool, webFetchTool, docSearchTool];
+//# sourceMappingURL=web.js.map

package/dist/ui/renderer.d.ts

@@ -0,0 +1,97 @@
+import { Theme } from './theme.js';
+import { TokenUsage } from '../core/types.js';
+export declare class TerminalUI {
+    theme: Theme;
+    private showTokens;
+    private showCost;
+    constructor(themeName?: string, showTokens?: boolean, showCost?: boolean);
+    /**
+     * Print the banner / splash screen
+     */
+    banner(): void;
+    /**
+     * Print user message
+     */
+    userMessage(content: string): void;
+    /**
+     * Print assistant message with markdown-like formatting
+     */
+    assistantMessage(content: string): void;
+    /**
+     * Print streaming token
+     */
+    streamingToken(token: string): void;
+    /**
+     * Start streaming block
+     */
+    startStreaming(): void;
+    /**
+     * End streaming block
+     */
+    endStreaming(): void;
+    /**
+     * Print thinking indicator
+     */
+    thinking(message: string): void;
+    /**
+     * Print tool call
+     */
+    toolCall(name: string, args: Record<string, unknown>): void;
+    /**
+     * Print tool result
+     */
+    toolResult(name: string, result: string, isError: boolean): void;
+    /**
+     * Print approval request
+     */
+    approvalRequest(toolName: string, args: Record<string, unknown>, risk: 'low' | 'medium' | 'high'): boolean;
+    /**
+     * Print token usage
+     */
+    tokenUsage(usage: TokenUsage, modelId: string): void;
+    /**
+     * Print session stats
+     */
+    sessionStats(totalInput: number, totalOutput: number, totalCost: number): void;
+    /**
+     * Print agent activity
+     */
+    agentActivity(agentName: string, status: 'starting' | 'working' | 'done' | 'error'): void;
+    /**
+     * Print error
+     */
+    error(message: string): void;
+    /**
+     * Print info
+     */
+    info(message: string): void;
+    /**
+     * Print success
+     */
+    success(message: string): void;
+    /**
+     * Print warning
+     */
+    warning(message: string): void;
+    /**
+     * Print separator
+     */
+    separator(): void;
+    /**
+     * Print code block
+     */
+    codeBlock(code: string, language?: string): void;
+    /**
+     * Print model selection menu
+     */
+    modelList(selectedModel: string): void;
+    /**
+     * Print agent list
+     */
+    agentList(agents: Array<{
+        name: string;
+        description: string;
+        model: string;
+    }>): void;
+}
+//# sourceMappingURL=renderer.d.ts.map