Meleki
40c8fee531
- StreamingTracker: CancellationTokenSource pro Session, Cancel()-Methode - ChatEndpoint: POST /api/chat/stop Endpoint, linkedCts verknüpft Stop-Token mit Client-Disconnect-Token - AnthropicService: cancellationToken an ExecuteTool durchgereicht - ToolService: CancellationToken-Parameter, execute-Tool verknüpft externen Token mit 180s-Timeout, killt Prozess bei Abbruch - Frontend: apiStopChat() + stopStreaming() ruft Backend-Stop auf
471 lines
22 KiB
C#
471 lines
22 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Text.RegularExpressions;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Microsoft.Extensions.FileSystemGlobbing;
|
|
using Microsoft.Extensions.FileSystemGlobbing.Abstractions;
|
|
|
|
namespace Gott.Services;
|
|
|
|
public class ToolService
|
|
{
|
|
public object[] GetToolDefinitions(bool includeFileTools = false, bool includeMemory = false)
|
|
{
|
|
var allTools = new List<object>();
|
|
if (includeFileTools)
|
|
allTools.AddRange(GetFileTools());
|
|
if (includeMemory)
|
|
allTools.AddRange(GetMemoryToolDefinitions());
|
|
return allTools.ToArray();
|
|
}
|
|
|
|
private object[] GetFileTools()
|
|
{
|
|
return new object[]
|
|
{
|
|
new
|
|
{
|
|
name = "read_file",
|
|
description = "Liest den Inhalt einer Datei. Gibt den Textinhalt zurück.",
|
|
input_schema = new
|
|
{
|
|
type = "object",
|
|
properties = new Dictionary<string, object>
|
|
{
|
|
["path"] = new { type = "string", description = "Relativer Dateipfad" }
|
|
},
|
|
required = new[] { "path" }
|
|
}
|
|
},
|
|
new
|
|
{
|
|
name = "write_file",
|
|
description = "Erstellt oder überschreibt eine Datei mit dem angegebenen Inhalt.",
|
|
input_schema = new
|
|
{
|
|
type = "object",
|
|
properties = new Dictionary<string, object>
|
|
{
|
|
["path"] = new { type = "string", description = "Relativer Dateipfad" },
|
|
["content"] = new { type = "string", description = "Dateiinhalt" }
|
|
},
|
|
required = new[] { "path", "content" }
|
|
}
|
|
},
|
|
new
|
|
{
|
|
name = "edit_file",
|
|
description = "Ersetzt einen exakten Textabschnitt in einer Datei. oldText muss exakt matchen.",
|
|
input_schema = new
|
|
{
|
|
type = "object",
|
|
properties = new Dictionary<string, object>
|
|
{
|
|
["path"] = new { type = "string", description = "Relativer Dateipfad" },
|
|
["old_text"] = new { type = "string", description = "Exakter Text der ersetzt werden soll" },
|
|
["new_text"] = new { type = "string", description = "Neuer Text" }
|
|
},
|
|
required = new[] { "path", "old_text", "new_text" }
|
|
}
|
|
},
|
|
new
|
|
{
|
|
name = "list_files",
|
|
description = "Listet Dateien und Ordner in einem Verzeichnis auf.",
|
|
input_schema = new
|
|
{
|
|
type = "object",
|
|
properties = new Dictionary<string, object>
|
|
{
|
|
["path"] = new { type = "string", description = "Relativer Verzeichnispfad (leer = Root)" }
|
|
},
|
|
required = Array.Empty<string>()
|
|
}
|
|
},
|
|
new
|
|
{
|
|
name = "delete_file",
|
|
description = "Löscht eine Datei oder ein leeres Verzeichnis.",
|
|
input_schema = new
|
|
{
|
|
type = "object",
|
|
properties = new Dictionary<string, object>
|
|
{
|
|
["path"] = new { type = "string", description = "Relativer Pfad zur Datei oder zum Verzeichnis" }
|
|
},
|
|
required = new[] { "path" }
|
|
}
|
|
},
|
|
new
|
|
{
|
|
name = "execute",
|
|
description = "Führt einen Shell-Befehl im Workspace-Verzeichnis aus. Gibt stdout und stderr zurück. Timeout: 180 Sekunden.",
|
|
input_schema = new
|
|
{
|
|
type = "object",
|
|
properties = new Dictionary<string, object>
|
|
{
|
|
["command"] = new { type = "string", description = "Shell-Befehl zum Ausführen" }
|
|
},
|
|
required = new[] { "command" }
|
|
}
|
|
},
|
|
new
|
|
{
|
|
name = "glob",
|
|
description = "Findet Dateien im Workspace anhand eines Glob-Patterns (z.B. '**/*.cs', 'src/*.js'). Gibt eine Liste passender Dateipfade zurück.",
|
|
input_schema = new
|
|
{
|
|
type = "object",
|
|
properties = new Dictionary<string, object>
|
|
{
|
|
["pattern"] = new { type = "string", description = "Glob-Pattern, z.B. '**/*.cs' oder 'src/**/*.js'" },
|
|
["path"] = new { type = "string", description = "Startverzeichnis (relativ zum Workspace, leer = Root)" }
|
|
},
|
|
required = new[] { "pattern" }
|
|
}
|
|
},
|
|
new
|
|
{
|
|
name = "grep",
|
|
description = "Durchsucht Dateien im Workspace nach einem Regex- oder Text-Pattern. Gibt Treffer mit Dateiname und Zeilennummer zurück.",
|
|
input_schema = new
|
|
{
|
|
type = "object",
|
|
properties = new Dictionary<string, object>
|
|
{
|
|
["pattern"] = new { type = "string", description = "Suchbegriff oder Regex-Pattern" },
|
|
["path"] = new { type = "string", description = "Zu durchsuchendes Verzeichnis oder Datei (relativ, leer = Root)" },
|
|
["glob"] = new { type = "string", description = "Dateifilter als Glob-Pattern, z.B. '*.cs' (leer = alle Dateien)" },
|
|
["case_sensitive"] = new { type = "boolean", description = "Groß-/Kleinschreibung beachten (Default: false)" }
|
|
},
|
|
required = new[] { "pattern" }
|
|
}
|
|
},
|
|
new
|
|
{
|
|
name = "todo_write",
|
|
description = "Schreibt die komplette Todo-Liste. Ersetzt immer die gesamte Liste. Nutze dies um Aufgaben zu planen und den Fortschritt zu verfolgen.",
|
|
input_schema = new
|
|
{
|
|
type = "object",
|
|
properties = new Dictionary<string, object>
|
|
{
|
|
["todos"] = new
|
|
{
|
|
type = "array",
|
|
description = "Liste aller Todo-Einträge",
|
|
items = new
|
|
{
|
|
type = "object",
|
|
properties = new Dictionary<string, object>
|
|
{
|
|
["id"] = new { type = "string", description = "Eindeutige ID (z.B. '1', '2', 'task-1')" },
|
|
["content"] = new { type = "string", description = "Beschreibung der Aufgabe" },
|
|
["status"] = new { type = "string", @enum = new[] { "pending", "in_progress", "completed" }, description = "Status der Aufgabe" },
|
|
["priority"] = new { type = "string", @enum = new[] { "high", "medium", "low" }, description = "Priorität (optional)" }
|
|
},
|
|
required = new[] { "id", "content", "status" }
|
|
}
|
|
}
|
|
},
|
|
required = new[] { "todos" }
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
private object[] GetMemoryToolDefinitions()
|
|
{
|
|
return new object[]
|
|
{
|
|
new
|
|
{
|
|
name = "memory_read",
|
|
description = "Liest eine Memory-Datei des Agents. Nutze dies um gespeicherte Erinnerungen, Notizen oder Kontextinformationen abzurufen.",
|
|
input_schema = new
|
|
{
|
|
type = "object",
|
|
properties = new Dictionary<string, object>
|
|
{
|
|
["path"] = new { type = "string", description = "Relativer Pfad zur Memory-Datei (z.B. 'MEMORY.md' oder 'memory/YYYY-MM-DD.md')" }
|
|
},
|
|
required = new[] { "path" }
|
|
}
|
|
},
|
|
new
|
|
{
|
|
name = "memory_write",
|
|
description = "Schreibt oder überschreibt eine Memory-Datei. Nutze dies um wichtige Informationen, Entscheidungen oder Präferenzen dauerhaft zu speichern.",
|
|
input_schema = new
|
|
{
|
|
type = "object",
|
|
properties = new Dictionary<string, object>
|
|
{
|
|
["path"] = new { type = "string", description = "Relativer Pfad zur Memory-Datei (z.B. 'MEMORY.md' oder 'memory/YYYY-MM-DD.md')" },
|
|
["content"] = new { type = "string", description = "Inhalt der Datei" },
|
|
["append"] = new { type = "boolean", description = "Wenn true, wird der Inhalt angehängt statt überschrieben (Default: false)" }
|
|
},
|
|
required = new[] { "path", "content" }
|
|
}
|
|
},
|
|
new
|
|
{
|
|
name = "memory_list",
|
|
description = "Listet alle Memory-Dateien des Agents auf.",
|
|
input_schema = new
|
|
{
|
|
type = "object",
|
|
properties = new Dictionary<string, object>
|
|
{
|
|
["path"] = new { type = "string", description = "Optionaler Unterpfad zum Auflisten (leer = Root)" }
|
|
},
|
|
required = Array.Empty<string>()
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
public async Task<string> ExecuteTool(string name, JsonElement input, string workspace, MemoryService memoryService = null, string agentId = null, CancellationToken cancellationToken = default)
|
|
{
|
|
switch (name)
|
|
{
|
|
case "read_file":
|
|
{
|
|
if (string.IsNullOrEmpty(workspace))
|
|
return "Fehler: Kein Workspace konfiguriert";
|
|
var path = ResolvePath(input.GetProperty("path").GetString() ?? "", workspace);
|
|
if (!File.Exists(path))
|
|
return $"Fehler: Datei nicht gefunden: {Path.GetRelativePath(workspace, path)}";
|
|
return File.ReadAllText(path);
|
|
}
|
|
case "write_file":
|
|
{
|
|
if (string.IsNullOrEmpty(workspace))
|
|
return "Fehler: Kein Workspace konfiguriert";
|
|
var path = ResolvePath(input.GetProperty("path").GetString() ?? "", workspace);
|
|
var dir = Path.GetDirectoryName(path);
|
|
if (dir != null) Directory.CreateDirectory(dir);
|
|
var content = input.GetProperty("content").GetString() ?? "";
|
|
File.WriteAllText(path, content);
|
|
return $"Datei geschrieben: {Path.GetRelativePath(workspace, path)} ({content.Length} Zeichen)";
|
|
}
|
|
case "edit_file":
|
|
{
|
|
if (string.IsNullOrEmpty(workspace))
|
|
return "Fehler: Kein Workspace konfiguriert";
|
|
var path = ResolvePath(input.GetProperty("path").GetString() ?? "", workspace);
|
|
if (!File.Exists(path))
|
|
return $"Fehler: Datei nicht gefunden: {Path.GetRelativePath(workspace, path)}";
|
|
var fileContent = File.ReadAllText(path);
|
|
var oldText = input.GetProperty("old_text").GetString() ?? "";
|
|
var newText = input.GetProperty("new_text").GetString() ?? "";
|
|
if (!fileContent.Contains(oldText))
|
|
return "Fehler: old_text nicht in der Datei gefunden. Exakter Match nötig.";
|
|
fileContent = fileContent.Replace(oldText, newText);
|
|
File.WriteAllText(path, fileContent);
|
|
return $"Datei bearbeitet: {Path.GetRelativePath(workspace, path)}";
|
|
}
|
|
case "list_files":
|
|
{
|
|
if (string.IsNullOrEmpty(workspace))
|
|
return "Fehler: Kein Workspace konfiguriert";
|
|
var path = ResolvePath(input.TryGetProperty("path", out var p) ? p.GetString() ?? "" : "", workspace);
|
|
if (!Directory.Exists(path))
|
|
return $"Fehler: Verzeichnis nicht gefunden: {Path.GetRelativePath(workspace, path)}";
|
|
var entries = new List<string>();
|
|
foreach (var dir in Directory.GetDirectories(path))
|
|
entries.Add(Path.GetRelativePath(workspace, dir) + "/");
|
|
foreach (var file in Directory.GetFiles(path))
|
|
entries.Add(Path.GetRelativePath(workspace, file));
|
|
return entries.Count == 0 ? "(leer)" : string.Join("\n", entries);
|
|
}
|
|
case "delete_file":
|
|
{
|
|
if (string.IsNullOrEmpty(workspace))
|
|
return "Fehler: Kein Workspace konfiguriert";
|
|
var path = ResolvePath(input.GetProperty("path").GetString() ?? "", workspace);
|
|
if (File.Exists(path))
|
|
{
|
|
File.Delete(path);
|
|
return $"Datei gelöscht: {Path.GetRelativePath(workspace, path)}";
|
|
}
|
|
if (Directory.Exists(path))
|
|
{
|
|
Directory.Delete(path, recursive: false);
|
|
return $"Verzeichnis gelöscht: {Path.GetRelativePath(workspace, path)}";
|
|
}
|
|
return $"Fehler: Nicht gefunden: {Path.GetRelativePath(workspace, path)}";
|
|
}
|
|
case "execute":
|
|
{
|
|
if (string.IsNullOrEmpty(workspace))
|
|
return "Fehler: Kein Workspace konfiguriert";
|
|
var command = input.GetProperty("command").GetString() ?? "";
|
|
var psi = new ProcessStartInfo
|
|
{
|
|
FileName = "/bin/bash",
|
|
WorkingDirectory = workspace,
|
|
RedirectStandardInput = true,
|
|
RedirectStandardOutput = true,
|
|
RedirectStandardError = true,
|
|
UseShellExecute = false,
|
|
CreateNoWindow = true
|
|
};
|
|
using var proc = Process.Start(psi);
|
|
if (proc == null) return "Fehler: Prozess konnte nicht gestartet werden";
|
|
await proc.StandardInput.WriteAsync(command);
|
|
proc.StandardInput.Close();
|
|
// Timeout (180s) UND externen CancellationToken verknüpfen
|
|
using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
|
|
cts.CancelAfter(TimeSpan.FromSeconds(180));
|
|
try
|
|
{
|
|
await proc.WaitForExitAsync(cts.Token);
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
proc.Kill(entireProcessTree: true);
|
|
// Wenn der externe Token abgebrochen wurde, weiterwerfen
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
return "Fehler: Timeout nach 180 Sekunden - Prozess abgebrochen";
|
|
}
|
|
var stdout = await proc.StandardOutput.ReadToEndAsync();
|
|
var stderr = await proc.StandardError.ReadToEndAsync();
|
|
var result = new StringBuilder();
|
|
if (!string.IsNullOrEmpty(stdout)) result.Append(stdout);
|
|
if (!string.IsNullOrEmpty(stderr))
|
|
{
|
|
if (result.Length > 0) result.Append("\n--- stderr ---\n");
|
|
result.Append(stderr);
|
|
}
|
|
if (result.Length == 0) result.Append($"(exit code {proc.ExitCode})");
|
|
else if (proc.ExitCode != 0) result.Append($"\n(exit code {proc.ExitCode})");
|
|
return result.ToString();
|
|
}
|
|
case "glob":
|
|
{
|
|
if (string.IsNullOrEmpty(workspace))
|
|
return "Fehler: Kein Workspace konfiguriert";
|
|
var pattern = input.GetProperty("pattern").GetString() ?? "*";
|
|
var basePath = input.TryGetProperty("path", out var gp) ? gp.GetString() ?? "" : "";
|
|
var searchRoot = string.IsNullOrEmpty(basePath)
|
|
? workspace
|
|
: ResolvePath(basePath, workspace);
|
|
if (!Directory.Exists(searchRoot))
|
|
return $"Fehler: Verzeichnis nicht gefunden: {basePath}";
|
|
var matcher = new Matcher();
|
|
matcher.AddInclude(pattern);
|
|
var dirInfo = new DirectoryInfoWrapper(new DirectoryInfo(searchRoot));
|
|
var result = matcher.Execute(dirInfo);
|
|
var matches = result.Files
|
|
.Select(f => Path.GetRelativePath(workspace, Path.Combine(searchRoot, f.Path)))
|
|
.OrderBy(f => f)
|
|
.ToList();
|
|
return matches.Count == 0 ? "(keine Treffer)" : string.Join("\n", matches);
|
|
}
|
|
case "grep":
|
|
{
|
|
if (string.IsNullOrEmpty(workspace))
|
|
return "Fehler: Kein Workspace konfiguriert";
|
|
var pattern = input.GetProperty("pattern").GetString() ?? "";
|
|
var searchPath = input.TryGetProperty("path", out var sp) ? sp.GetString() ?? "" : "";
|
|
var fileGlob = input.TryGetProperty("glob", out var fg) ? fg.GetString() ?? "*" : "*";
|
|
var caseSensitive = input.TryGetProperty("case_sensitive", out var cs) && cs.GetBoolean();
|
|
var regexOptions = caseSensitive ? RegexOptions.None : RegexOptions.IgnoreCase;
|
|
Regex regex;
|
|
try { regex = new Regex(pattern, regexOptions); }
|
|
catch { regex = new Regex(Regex.Escape(pattern), regexOptions); }
|
|
var searchRoot = string.IsNullOrEmpty(searchPath)
|
|
? workspace
|
|
: ResolvePath(searchPath, workspace);
|
|
IEnumerable<string> files;
|
|
if (File.Exists(searchRoot))
|
|
files = new[] { searchRoot };
|
|
else if (Directory.Exists(searchRoot))
|
|
files = Directory.GetFiles(searchRoot, fileGlob, SearchOption.AllDirectories);
|
|
else
|
|
return $"Fehler: Pfad nicht gefunden: {searchPath}";
|
|
var results = new List<string>();
|
|
foreach (var file in files.OrderBy(f => f))
|
|
{
|
|
string[] lines;
|
|
try { lines = File.ReadAllLines(file); }
|
|
catch { continue; }
|
|
for (var i = 0; i < lines.Length; i++)
|
|
{
|
|
if (regex.IsMatch(lines[i]))
|
|
results.Add($"{Path.GetRelativePath(workspace, file)}:{i + 1}: {lines[i].Trim()}");
|
|
}
|
|
}
|
|
if (results.Count == 0) return "(keine Treffer)";
|
|
if (results.Count > 500) results = results.Take(500).Append("... (auf 500 Treffer begrenzt)").ToList();
|
|
return string.Join("\n", results);
|
|
}
|
|
case "todo_write":
|
|
{
|
|
var todos = input.GetProperty("todos");
|
|
var sb = new StringBuilder();
|
|
foreach (var todo in todos.EnumerateArray())
|
|
{
|
|
var id = todo.GetProperty("id").GetString();
|
|
var content = todo.GetProperty("content").GetString();
|
|
var status = todo.GetProperty("status").GetString();
|
|
var priority = todo.TryGetProperty("priority", out var prio) ? prio.GetString() : null;
|
|
var icon = status switch { "completed" => "✅", "in_progress" => "🔄", _ => "⬜" };
|
|
var prioTag = priority != null ? $" [{priority}]" : "";
|
|
sb.AppendLine($"{icon} [{id}]{prioTag} {content}");
|
|
}
|
|
return sb.Length == 0 ? "(leere Todo-Liste)" : sb.ToString().TrimEnd();
|
|
}
|
|
case "memory_read":
|
|
{
|
|
if (memoryService == null || string.IsNullOrEmpty(agentId))
|
|
return "Fehler: Memory-Service nicht verfügbar";
|
|
var path = input.GetProperty("path").GetString() ?? "";
|
|
var content = memoryService.ReadMemoryFile(agentId, path);
|
|
if (content == null)
|
|
return $"Datei nicht gefunden: {path}";
|
|
return content;
|
|
}
|
|
case "memory_write":
|
|
{
|
|
if (memoryService == null || string.IsNullOrEmpty(agentId))
|
|
return "Fehler: Memory-Service nicht verfügbar";
|
|
var path = input.GetProperty("path").GetString() ?? "";
|
|
var content = input.GetProperty("content").GetString() ?? "";
|
|
var append = input.TryGetProperty("append", out var a) && a.GetBoolean();
|
|
if (append)
|
|
memoryService.AppendMemoryFile(agentId, path, content);
|
|
else
|
|
memoryService.WriteMemoryFile(agentId, path, content);
|
|
return $"Memory-Datei {(append ? "erweitert" : "geschrieben")}: {path} ({content.Length} Zeichen)";
|
|
}
|
|
case "memory_list":
|
|
{
|
|
if (memoryService == null || string.IsNullOrEmpty(agentId))
|
|
return "Fehler: Memory-Service nicht verfügbar";
|
|
var subPath = input.TryGetProperty("path", out var p) ? p.GetString() ?? "" : "";
|
|
var files = memoryService.ListMemoryFiles(agentId, subPath);
|
|
return files.Count == 0 ? "(keine Memory-Dateien vorhanden)" : string.Join("\n", files);
|
|
}
|
|
default:
|
|
return $"Fehler: Unbekanntes Tool: {name}";
|
|
}
|
|
}
|
|
|
|
private string ResolvePath(string relativePath, string workspace)
|
|
{
|
|
var full = Path.GetFullPath(Path.Combine(workspace, relativePath ?? ""));
|
|
if (!full.StartsWith(workspace))
|
|
throw new Exception("Zugriff außerhalb des Workspace nicht erlaubt");
|
|
return full;
|
|
}
|
|
}
|