neoagent 1.0.0

package/server/services/ai/providers/ollama.js

@@ -0,0 +1,162 @@
+const { BaseProvider } = require('./base');
+
+class OllamaProvider extends BaseProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'ollama';
+    this.baseUrl = config.baseUrl || process.env.OLLAMA_URL || 'http://localhost:11434';
+    this.models = [];
+  }
+
+  async listModels() {
+    try {
+      const res = await fetch(`${this.baseUrl}/api/tags`);
+      const data = await res.json();
+      this.models = (data.models || []).map(m => m.name);
+      return this.models;
+    } catch {
+      return [];
+    }
+  }
+
+  getContextWindow(model) {
+    return 128000;
+  }
+
+  formatToolsForOllama(tools) {
+    return tools.map(tool => ({
+      type: 'function',
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters || { type: 'object', properties: {} }
+      }
+    }));
+  }
+
+  async chat(messages, tools = [], options = {}) {
+    const model = options.model || this.config.model || 'llama3.1';
+    const body = {
+      model,
+      messages: messages.map(m => ({
+        role: m.role,
+        content: m.content || '',
+        ...(m.tool_calls ? { tool_calls: m.tool_calls } : {}),
+        ...(m.tool_call_id ? { tool_call_id: m.tool_call_id } : {})
+      })),
+      stream: false,
+      options: {
+        temperature: options.temperature ?? 0.7,
+        num_predict: options.maxTokens || 16384
+      }
+    };
+
+    if (tools.length > 0) {
+      body.tools = this.formatToolsForOllama(tools);
+    }
+
+    const res = await fetch(`${this.baseUrl}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body)
+    });
+
+    const data = await res.json();
+    const msg = data.message || {};
+
+    return {
+      content: msg.content || '',
+      toolCalls: (msg.tool_calls || []).map((tc, i) => ({
+        id: `call_ollama_${Date.now()}_${i}`,
+        type: 'function',
+        function: {
+          name: tc.function.name,
+          arguments: JSON.stringify(tc.function.arguments || {})
+        }
+      })),
+      finishReason: msg.tool_calls?.length > 0 ? 'tool_calls' : 'stop',
+      usage: data.prompt_eval_count ? {
+        promptTokens: data.prompt_eval_count || 0,
+        completionTokens: data.eval_count || 0,
+        totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0)
+      } : null,
+      model: data.model || model
+    };
+  }
+
+  async *stream(messages, tools = [], options = {}) {
+    const model = options.model || this.config.model || 'llama3.1';
+    const body = {
+      model,
+      messages: messages.map(m => ({
+        role: m.role,
+        content: m.content || '',
+        ...(m.tool_calls ? { tool_calls: m.tool_calls } : {}),
+        ...(m.tool_call_id ? { tool_call_id: m.tool_call_id } : {})
+      })),
+      stream: true,
+      options: {
+        temperature: options.temperature ?? 0.7,
+        num_predict: options.maxTokens || 16384
+      }
+    };
+
+    if (tools.length > 0) {
+      body.tools = this.formatToolsForOllama(tools);
+    }
+
+    const res = await fetch(`${this.baseUrl}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body)
+    });
+
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let content = '';
+    let buffer = '';
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const data = JSON.parse(line);
+          if (data.message?.content) {
+            content += data.message.content;
+            yield { type: 'content', content: data.message.content };
+          }
+          if (data.done) {
+            const toolCalls = (data.message?.tool_calls || []).map((tc, i) => ({
+              id: `call_ollama_${Date.now()}_${i}`,
+              type: 'function',
+              function: {
+                name: tc.function.name,
+                arguments: JSON.stringify(tc.function.arguments || {})
+              }
+            }));
+            yield {
+              type: 'done',
+              content,
+              toolCalls,
+              finishReason: toolCalls.length > 0 ? 'tool_calls' : 'stop',
+              usage: data.prompt_eval_count ? {
+                promptTokens: data.prompt_eval_count || 0,
+                completionTokens: data.eval_count || 0,
+                totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0)
+              } : null
+            };
+          }
+        } catch {}
+      }
+    }
+  }
+}
+
+module.exports = { OllamaProvider };

package/server/services/ai/providers/openai.js

@@ -0,0 +1,167 @@
+const OpenAI = require('openai');
+const { BaseProvider } = require('./base');
+
+class OpenAIProvider extends BaseProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'openai';
+    this.models = [
+      'gpt-5',
+      'gpt-5-mini',
+      'gpt-5-nano',
+      'gpt-5.2',
+      'gpt-4.1',
+      'o3',
+      'o4-mini'
+    ];
+    // Reasoning models: no temperature, use max_completion_tokens, support reasoning_effort
+    this.reasoningModels = new Set(['gpt-5', 'gpt-5-mini', 'gpt-5-nano', 'gpt-5.2', 'gpt-5.1', 'o1', 'o3', 'o4-mini', 'o3-mini']);
+    this.contextWindows = {
+      'gpt-5': 400000,
+      'gpt-5-mini': 200000,
+      'gpt-5-nano': 128000,
+      'gpt-5.2': 400000,
+      'gpt-5.1': 400000,
+      'gpt-4.1': 1047576,
+      'o3': 200000,
+      'o4-mini': 200000,
+      'o3-mini': 200000
+    };
+    this.client = new OpenAI({
+      apiKey: config.apiKey || process.env.OPENAI_API_KEY
+    });
+  }
+
+  isReasoningModel(model) {
+    // Match exact IDs and prefix variants (gpt-5-2025-08-07 etc)
+    for (const id of this.reasoningModels) {
+      if (model === id || model.startsWith(id + '-')) return true;
+    }
+    return false;
+  }
+
+  getContextWindow(model) {
+    for (const [id, size] of Object.entries(this.contextWindows)) {
+      if (model === id || model.startsWith(id + '-')) return size;
+    }
+    return 128000;
+  }
+
+  _buildParams(model, messages, tools, options) {
+    const isReasoning = this.isReasoningModel(model);
+    // Reasoning models (GPT-5, o-series): use developer role for system messages
+    const formattedMessages = isReasoning
+      ? messages.map(m => m.role === 'system' ? { ...m, role: 'developer' } : m)
+      : messages;
+
+    const params = {
+      model,
+      messages: formattedMessages
+    };
+
+    if (isReasoning) {
+      // max_completion_tokens (not max_tokens) for reasoning models
+      params.max_completion_tokens = options.maxTokens || 16384;
+      // reasoning_effort: low/medium/high (default medium for speed/quality balance)
+      if (options.reasoningEffort || options.reasoning_effort) {
+        params.reasoning_effort = options.reasoningEffort || options.reasoning_effort;
+      }
+      // No temperature for reasoning models
+    } else {
+      params.temperature = options.temperature ?? 0.7;
+      params.max_tokens = options.maxTokens || 16384;
+    }
+
+    if (tools && tools.length > 0) {
+      params.tools = this.formatTools(tools);
+      params.tool_choice = options.toolChoice || 'auto';
+    }
+
+    return params;
+  }
+
+  async chat(messages, tools = [], options = {}) {
+    const model = options.model || this.config.model || this.getDefaultModel();
+    const params = this._buildParams(model, messages, tools, options);
+
+    const response = await this.client.chat.completions.create(params);
+    const choice = response.choices[0];
+
+    return {
+      content: choice.message.content,
+      toolCalls: choice.message.tool_calls || [],
+      finishReason: choice.finish_reason,
+      usage: response.usage ? {
+        promptTokens: response.usage.prompt_tokens,
+        completionTokens: response.usage.completion_tokens,
+        totalTokens: response.usage.total_tokens
+      } : null,
+      model: response.model
+    };
+  }
+
+  async *stream(messages, tools = [], options = {}) {
+    const model = options.model || this.config.model || this.getDefaultModel();
+    const params = this._buildParams(model, messages, tools, options);
+    params.stream = true;
+    params.stream_options = { include_usage: true };
+    const stream = await this.client.chat.completions.create(params);
+
+    let currentToolCalls = [];
+    let content = '';
+    let finalUsage = null;
+
+    for await (const chunk of stream) {
+      // Final usage-only chunk (empty choices array)
+      if (chunk.usage && (!chunk.choices || chunk.choices.length === 0)) {
+        finalUsage = {
+          promptTokens: chunk.usage.prompt_tokens,
+          completionTokens: chunk.usage.completion_tokens,
+          totalTokens: chunk.usage.total_tokens
+        };
+        continue;
+      }
+
+      const delta = chunk.choices[0]?.delta;
+      if (!delta) continue;
+
+      if (delta.content) {
+        content += delta.content;
+        yield { type: 'content', content: delta.content };
+      }
+
+      if (delta.tool_calls) {
+        for (const tc of delta.tool_calls) {
+          if (tc.index !== undefined) {
+            if (!currentToolCalls[tc.index]) {
+              currentToolCalls[tc.index] = {
+                id: tc.id || '',
+                type: 'function',
+                function: { name: '', arguments: '' }
+              };
+            }
+            if (tc.id) currentToolCalls[tc.index].id = tc.id;
+            if (tc.function?.name) currentToolCalls[tc.index].function.name += tc.function.name;
+            if (tc.function?.arguments) currentToolCalls[tc.index].function.arguments += tc.function.arguments;
+          }
+        }
+      }
+
+      if (chunk.choices[0]?.finish_reason) {
+        yield {
+          type: 'done',
+          content,
+          toolCalls: currentToolCalls.filter(tc => tc.id),
+          finishReason: chunk.choices[0].finish_reason,
+          usage: chunk.usage ? {
+            promptTokens: chunk.usage.prompt_tokens,
+            completionTokens: chunk.usage.completion_tokens,
+            totalTokens: chunk.usage.total_tokens
+          } : finalUsage
+        };
+      }
+    }
+  }
+}
+
+module.exports = { OpenAIProvider };

package/server/services/ai/toolRunner.js

@@ -0,0 +1,218 @@
+const fs = require('fs');
+const path = require('path');
+const db = require('../../db/database');
+
+const SKILLS_DIR = path.join(__dirname, '..', '..', '..', 'agent-data', 'skills');
+
+class SkillRunner {
+  constructor() {
+    this.skills = new Map();
+  }
+
+  async loadSkills() {
+    this.skills.clear();
+    if (!fs.existsSync(SKILLS_DIR)) return;
+
+    const loadDir = (dir) => {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          const skillFile = path.join(fullPath, 'SKILL.md');
+          if (fs.existsSync(skillFile)) {
+            this.loadSkillFile(skillFile);
+          }
+          loadDir(fullPath);
+        } else if (entry.name.endsWith('.md')) {
+          this.loadSkillFile(fullPath);
+        }
+      }
+    };
+
+    loadDir(SKILLS_DIR);
+
+    const dbSkills = db.prepare('SELECT * FROM skills WHERE enabled = 1').all();
+    for (const skill of dbSkills) {
+      if (fs.existsSync(skill.file_path)) {
+        this.loadSkillFile(skill.file_path);
+      }
+    }
+  }
+
+  loadSkillFile(filePath) {
+    try {
+      const content = fs.readFileSync(filePath, 'utf-8');
+      const skill = this.parseSkillMd(content, filePath);
+      if (skill) {
+        this.skills.set(skill.name, skill);
+      }
+    } catch (err) {
+      console.error(`Failed to load skill from ${filePath}:`, err.message);
+    }
+  }
+
+  parseSkillMd(content, filePath) {
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)/);
+    if (!frontmatterMatch) return null;
+
+    const frontmatter = frontmatterMatch[1];
+    const body = frontmatterMatch[2];
+
+    const metadata = {};
+    const lines = frontmatter.split('\n');
+    for (const line of lines) {
+      const match = line.match(/^(\w[\w-]*)\s*:\s*(.+)$/);
+      if (match) {
+        const key = match[1].trim();
+        let value = match[2].trim();
+        if (value.startsWith('{') || value.startsWith('[')) {
+          try { value = JSON.parse(value); } catch {}
+        } else if (value === 'true') value = true;
+        else if (value === 'false') value = false;
+        metadata[key] = value;
+      }
+    }
+
+    if (!metadata.name) return null;
+
+    return {
+      name: metadata.name,
+      description: metadata.description || '',
+      metadata,
+      instructions: body.trim(),
+      filePath,
+      dir: path.dirname(filePath)
+    };
+  }
+
+  getSkillsForPrompt() {
+    const skills = Array.from(this.skills.values());
+    if (skills.length === 0) return '';
+
+    let prompt = '\n## Available Skills\n';
+    for (const skill of skills) {
+      prompt += `\n### ${skill.name}\n${skill.description}\n`;
+      if (skill.instructions) {
+        prompt += `${skill.instructions.slice(0, 500)}\n`;
+      }
+    }
+    return prompt;
+  }
+
+  getToolDefinitions() {
+    const tools = [];
+    for (const skill of this.skills.values()) {
+      if (skill.metadata.tool) {
+        tools.push({
+          name: skill.name,
+          description: skill.description,
+          parameters: skill.metadata.parameters || { type: 'object', properties: {} }
+        });
+      }
+    }
+    return tools;
+  }
+
+  async executeTool(toolName, args) {
+    const skill = this.skills.get(toolName);
+    if (!skill) return null;
+
+    if (skill.metadata.command) {
+      const { CLIExecutor } = require('../cli/executor');
+      const executor = new CLIExecutor();
+      let command = skill.metadata.command;
+      for (const [key, value] of Object.entries(args)) {
+        command = command.replace(`{${key}}`, value);
+      }
+      return await executor.execute(command, { cwd: skill.dir });
+    }
+
+    return { skill: skill.name, instructions: skill.instructions, args };
+  }
+
+  createSkill(name, description, instructions, metadata = {}) {
+    const safeName = name.replace(/[^a-z0-9-]/gi, '-').toLowerCase();
+    const skillDir = path.join(SKILLS_DIR, safeName);
+    if (!fs.existsSync(skillDir)) fs.mkdirSync(skillDir, { recursive: true });
+
+    const frontmatter = this._buildFrontmatter(safeName, description, metadata);
+    const filePath = path.join(skillDir, 'SKILL.md');
+    fs.writeFileSync(filePath, frontmatter + `\n\n${instructions}`);
+
+    db.prepare('INSERT OR REPLACE INTO skills (name, description, file_path, metadata, auto_created, updated_at) VALUES (?, ?, ?, ?, 1, datetime(\'now\'))')
+      .run(safeName, description, filePath, JSON.stringify(metadata));
+
+    this.loadSkillFile(filePath);
+
+    return { success: true, name: safeName, path: filePath };
+  }
+
+  updateSkill(name, { description, instructions, metadata } = {}) {
+    const skill = this.skills.get(name);
+    if (!skill) return { error: `Skill '${name}' not found` };
+
+    const newDesc = description !== undefined ? description : skill.description;
+    const newInstructions = instructions !== undefined ? instructions : skill.instructions;
+    // Merge: if metadata provided use it, otherwise preserve existing non-name/description fields
+    let metaToWrite = {};
+    if (metadata !== undefined) {
+      metaToWrite = metadata;
+    } else {
+      const existing = { ...skill.metadata };
+      delete existing.name;
+      delete existing.description;
+      metaToWrite = existing;
+    }
+
+    const frontmatter = this._buildFrontmatter(name, newDesc, metaToWrite);
+    fs.writeFileSync(skill.filePath, frontmatter + `\n\n${newInstructions}`);
+    db.prepare('UPDATE skills SET description = ?, updated_at = datetime(\'now\') WHERE name = ?').run(newDesc, name);
+    this.loadSkillFile(skill.filePath);
+
+    return { success: true, name, path: skill.filePath };
+  }
+
+  deleteSkill(name) {
+    const skill = this.skills.get(name);
+    if (!skill) return { error: `Skill '${name}' not found` };
+
+    try {
+      fs.unlinkSync(skill.filePath);
+      const dir = path.dirname(skill.filePath);
+      if (path.basename(skill.filePath) === 'SKILL.md') {
+        const remaining = fs.readdirSync(dir);
+        if (remaining.length === 0) fs.rmdirSync(dir);
+      }
+    } catch (e) { /* ignore */ }
+
+    db.prepare('DELETE FROM skills WHERE name = ?').run(name);
+    this.skills.delete(name);
+
+    return { success: true, deleted: name };
+  }
+
+  _buildFrontmatter(name, description, metadata = {}) {
+    let fm = `---\nname: ${name}\ndescription: ${description}\n`;
+    if (metadata && typeof metadata === 'object') {
+      for (const [key, val] of Object.entries(metadata)) {
+        if (key === 'name' || key === 'description') continue;
+        fm += typeof val === 'object'
+          ? `${key}: ${JSON.stringify(val)}\n`
+          : `${key}: ${val}\n`;
+      }
+    }
+    fm += `---`;
+    return fm;
+  }
+
+  getAll() {
+    return Array.from(this.skills.values()).map(s => ({
+      name: s.name,
+      description: s.description,
+      metadata: s.metadata,
+      filePath: s.filePath
+    }));
+  }
+}
+
+module.exports = { SkillRunner };