scorpion-cli 0.1.0

package/src/index.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+/**
+ * Scorpion CLI
+ * An agentic AI assistant powered by Ollama
+ * Inspired by Claude Code & Gemini CLI
+ */
+
+import { program } from 'commander';
+import { startREPL } from './ui/repl.js';
+import { query } from './agent.js';
+import { isModelAvailable, DEFAULT_MODEL } from './ollama.js';
+import {
+    displayBanner,
+    showError,
+    showSuccess,
+    showInfo,
+    colors
+} from './ui/formatter.js';
+
+// Package info
+const VERSION = '0.1.0';
+const NAME = 'scorpion';
+
+// Setup CLI
+program
+    .name(NAME)
+    .version(VERSION)
+    .description('🦂 Scorpion - Agentic AI CLI powered by Ollama')
+    .option('-m, --model <model>', 'Ollama model to use', DEFAULT_MODEL)
+    .option('-q, --query <query>', 'Run a single query and exit')
+    .option('--think', 'Show AI thinking process')
+    .option('--check', 'Check Ollama connection and exit');
+
+program.parse();
+
+const options = program.opts();
+
+// Main entry point
+async function main() {
+    // Handle --check flag
+    if (options.check) {
+        showInfo('Checking Ollama connection...');
+        try {
+            const available = await isModelAvailable(options.model);
+            if (available) {
+                showSuccess(`Ollama is running. Model '${options.model}' is available.`);
+            } else {
+                showError(`Model '${options.model}' not found.`);
+                showInfo(`Run: ollama pull ${options.model}`);
+            }
+        } catch (error) {
+            showError('Could not connect to Ollama.');
+            showInfo('Make sure Ollama is running: ollama serve');
+        }
+        process.exit(0);
+    }
+
+    // Handle --query flag (single query mode)
+    if (options.query) {
+        try {
+            console.log(colors.dim('\n  Processing...\n'));
+
+            const result = await query(options.query);
+
+            console.log(colors.white('  ' + result.content.split('\n').join('\n  ')));
+            console.log();
+            process.exit(0);
+        } catch (error) {
+            showError(error.message);
+            process.exit(1);
+        }
+    }
+
+    // Start interactive REPL
+    await startREPL({
+        model: options.model,
+        showThinkingOutput: options.think || false,
+    });
+}
+
+// Run
+main().catch((error) => {
+    showError(error.message);
+    process.exit(1);
+});

package/src/ollama.js

@@ -0,0 +1,126 @@
+/**
+ * Ollama Client Wrapper
+ * Provides a centralized interface to the Ollama API
+ */
+
+import { Ollama } from 'ollama';
+
+// Default configuration
+const DEFAULT_MODEL = process.env.OLLAMA_MODEL || 'qwen3.5:0.8b';
+const DEFAULT_HOST = 'http://localhost:11434';
+
+// Create the Ollama client
+const ollama = new Ollama({ host: process.env.OLLAMA_HOST || DEFAULT_HOST });
+
+/**
+ * Chat with the model using tool calling
+ * @param {Object} options - Chat options
+ * @param {string} options.model - Model name
+ * @param {Array} options.messages - Conversation messages
+ * @param {Array} options.tools - Available tools
+ * @param {boolean} options.think - Enable thinking mode
+ * @param {boolean} options.stream - Enable streaming
+ * @returns {Promise} - Chat response or async iterator for streaming
+ */
+export async function chat(options) {
+  const {
+    model = DEFAULT_MODEL,
+    messages,
+    tools = [],
+    think = true,
+    stream = false,
+    format = undefined,
+  } = options;
+
+  return ollama.chat({
+    model,
+    messages,
+    tools: tools.length > 0 ? tools : undefined,
+    think,
+    stream,
+    format,
+  });
+}
+
+/**
+ * Web search using Ollama's API (requires API key)
+ * @param {string} query - Search query
+ * @param {number} maxResults - Maximum results to return
+ * @returns {Promise<Array>} - Search results
+ */
+export async function webSearch(query, maxResults = 5) {
+  try {
+    const results = await ollama.webSearch({ query, max_results: maxResults });
+    return results;
+  } catch (error) {
+    // Fallback: return error message if API key not set
+    if (error.message?.includes('unauthorized') || error.message?.includes('API key')) {
+      return {
+        error: 'Web search requires OLLAMA_API_KEY. Set it in your environment.',
+        suggestion: 'Get your API key at https://ollama.com/settings/keys'
+      };
+    }
+    throw error;
+  }
+}
+
+/**
+ * Fetch a web page using Ollama's API
+ * @param {string} url - URL to fetch
+ * @returns {Promise<Object>} - Page content
+ */
+export async function webFetch(url) {
+  try {
+    const result = await ollama.webFetch({ url });
+    return result;
+  } catch (error) {
+    if (error.message?.includes('unauthorized') || error.message?.includes('API key')) {
+      return {
+        error: 'Web fetch requires OLLAMA_API_KEY. Set it in your environment.',
+        suggestion: 'Get your API key at https://ollama.com/settings/keys'
+      };
+    }
+    throw error;
+  }
+}
+
+/**
+ * List available models
+ * @returns {Promise<Array>} - List of models
+ */
+export async function listModels() {
+  const response = await ollama.list();
+  return response.models;
+}
+
+/**
+ * Check if a model is available
+ * @param {string} modelName - Model to check
+ * @returns {Promise<boolean>} - True if available
+ */
+export async function isModelAvailable(modelName = DEFAULT_MODEL) {
+    try {
+        const models = await listModels();
+        return models.some((m) => m.name === modelName || (
+            !modelName.includes(':') && m.name.split(':')[0] === modelName
+        ));
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Pull a model if not available
+ * @param {string} modelName - Model to pull
+ * @param {Function} onProgress - Progress callback
+ */
+export async function pullModel(modelName, onProgress) {
+  const stream = await ollama.pull({ model: modelName, stream: true });
+  for await (const part of stream) {
+    if (onProgress) {
+      onProgress(part);
+    }
+  }
+}
+
+export { ollama, DEFAULT_MODEL, DEFAULT_HOST };

package/src/registry.js

@@ -0,0 +1,112 @@
+/**
+ * Tool Registry
+ * Manages all available tools and their schemas for the agent
+ */
+
+import * as shellTools from './tools/shell.js';
+import * as filesystemTools from './tools/filesystem.js';
+import * as systemTools from './tools/system.js';
+import * as webTools from './tools/web.js';
+import * as documentTools from './tools/documents.js';
+import * as contextTools from './tools/context.js';
+import * as deepResearchTools from './tools/deep-research.js';
+
+// Collect all tool modules
+const toolModules = {
+    ...shellTools,
+    ...filesystemTools,
+    ...systemTools,
+    ...webTools,
+    ...documentTools,
+    ...contextTools,
+    ...deepResearchTools,
+};
+
+/**
+ * Get all tool schemas for Ollama API
+ * @returns {Array} - Array of tool definitions
+ */
+export function getAllToolSchemas() {
+    return Object.values(toolModules)
+        .filter(tool => tool.schema)
+        .map(tool => tool.schema);
+}
+
+/**
+ * Get a tool executor by name
+ * @param {string} name - Tool name
+ * @returns {Function|null} - Tool executor function
+ */
+export function getToolExecutor(name) {
+    const tool = Object.values(toolModules).find(t => t.schema?.function?.name === name);
+    return tool?.execute || null;
+}
+
+/**
+ * Execute a tool by name with arguments
+ * @param {string} name - Tool name
+ * @param {Object} args - Tool arguments
+ * @returns {Promise<string>} - Tool result as string
+ */
+export async function executeTool(name, args) {
+    const executor = getToolExecutor(name);
+    if (!executor) {
+        return JSON.stringify({ error: `Tool '${name}' not found` });
+    }
+
+    try {
+        const result = await executor(args);
+        return typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+    } catch (error) {
+        return JSON.stringify({
+            error: error.message,
+            tool: name,
+            args
+        });
+    }
+}
+
+/**
+ * Get tool categories for help display
+ * @returns {Object} - Tools grouped by category
+ */
+export function getToolsByCategory() {
+    return {
+        'Shell': Object.values(shellTools).filter(t => t.schema).map(t => ({
+            name: t.schema.function.name,
+            description: t.schema.function.description
+        })),
+        'File System': Object.values(filesystemTools).filter(t => t.schema).map(t => ({
+            name: t.schema.function.name,
+            description: t.schema.function.description
+        })),
+        'System': Object.values(systemTools).filter(t => t.schema).map(t => ({
+            name: t.schema.function.name,
+            description: t.schema.function.description
+        })),
+        'Web': Object.values(webTools).filter(t => t.schema).map(t => ({
+            name: t.schema.function.name,
+            description: t.schema.function.description
+        })),
+        'Documents': Object.values(documentTools).filter(t => t.schema).map(t => ({
+            name: t.schema.function.name,
+            description: t.schema.function.description
+        })),
+        'Context': Object.values(contextTools).filter(t => t.schema).map(t => ({
+            name: t.schema.function.name,
+            description: t.schema.function.description
+        })),
+        'Deep Research': Object.values(deepResearchTools).filter(t => t.schema).map(t => ({
+            name: t.schema.function.name,
+            description: t.schema.function.description
+        })),
+    };
+}
+
+/**
+ * Get total number of available tools
+ * @returns {number} - Tool count
+ */
+export function getToolCount() {
+    return getAllToolSchemas().length;
+}