274 lines
9.0 KiB
C#
274 lines
9.0 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using System.Text.Json;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using System.Xml;
|
|
using System.Xml.Linq;
|
|
using System.Xml.XPath;
|
|
|
|
namespace AxCopilot.Services.Agent;
|
|
|
|
public class XmlTool : IAgentTool
|
|
{
|
|
public string Name => "xml_tool";
|
|
|
|
public string Description => "Parse and query XML documents. Actions: 'parse' — parse XML file/string and return structure summary; 'xpath' — evaluate XPath expression and return matching nodes; 'to_json' — convert XML to JSON; 'format' — pretty-print XML with indentation.";
|
|
|
|
public ToolParameterSchema Parameters
|
|
{
|
|
get
|
|
{
|
|
ToolParameterSchema toolParameterSchema = new ToolParameterSchema();
|
|
Dictionary<string, ToolProperty> dictionary = new Dictionary<string, ToolProperty>();
|
|
ToolProperty obj = new ToolProperty
|
|
{
|
|
Type = "string",
|
|
Description = "Action: parse, xpath, to_json, format"
|
|
};
|
|
int num = 4;
|
|
List<string> list = new List<string>(num);
|
|
CollectionsMarshal.SetCount(list, num);
|
|
Span<string> span = CollectionsMarshal.AsSpan(list);
|
|
span[0] = "parse";
|
|
span[1] = "xpath";
|
|
span[2] = "to_json";
|
|
span[3] = "format";
|
|
obj.Enum = list;
|
|
dictionary["action"] = obj;
|
|
dictionary["path"] = new ToolProperty
|
|
{
|
|
Type = "string",
|
|
Description = "XML file path (optional if 'xml' is provided)"
|
|
};
|
|
dictionary["xml"] = new ToolProperty
|
|
{
|
|
Type = "string",
|
|
Description = "XML string (optional if 'path' is provided)"
|
|
};
|
|
dictionary["expression"] = new ToolProperty
|
|
{
|
|
Type = "string",
|
|
Description = "XPath expression (for 'xpath' action)"
|
|
};
|
|
toolParameterSchema.Properties = dictionary;
|
|
num = 1;
|
|
List<string> list2 = new List<string>(num);
|
|
CollectionsMarshal.SetCount(list2, num);
|
|
CollectionsMarshal.AsSpan(list2)[0] = "action";
|
|
toolParameterSchema.Required = list2;
|
|
return toolParameterSchema;
|
|
}
|
|
}
|
|
|
|
public Task<ToolResult> ExecuteAsync(JsonElement args, AgentContext context, CancellationToken ct = default(CancellationToken))
|
|
{
|
|
string text = args.GetProperty("action").GetString() ?? "";
|
|
JsonElement value;
|
|
string text2 = (args.TryGetProperty("xml", out value) ? (value.GetString() ?? "") : "");
|
|
JsonElement value2;
|
|
string text3 = (args.TryGetProperty("path", out value2) ? (value2.GetString() ?? "") : "");
|
|
JsonElement value3;
|
|
string xpath = (args.TryGetProperty("expression", out value3) ? (value3.GetString() ?? "") : "");
|
|
try
|
|
{
|
|
if (string.IsNullOrEmpty(text2) && !string.IsNullOrEmpty(text3))
|
|
{
|
|
string text4 = (Path.IsPathRooted(text3) ? text3 : Path.Combine(context.WorkFolder, text3));
|
|
if (!context.IsPathAllowed(text4))
|
|
{
|
|
return Task.FromResult(ToolResult.Fail("경로 접근 차단: " + text4));
|
|
}
|
|
if (!File.Exists(text4))
|
|
{
|
|
return Task.FromResult(ToolResult.Fail("파일 없음: " + text4));
|
|
}
|
|
text2 = File.ReadAllText(text4);
|
|
}
|
|
if (string.IsNullOrEmpty(text2))
|
|
{
|
|
return Task.FromResult(ToolResult.Fail("'xml' 또는 'path' 중 하나를 지정해야 합니다."));
|
|
}
|
|
XDocument doc = XDocument.Parse(text2);
|
|
if (1 == 0)
|
|
{
|
|
}
|
|
Task<ToolResult> result = text switch
|
|
{
|
|
"parse" => Task.FromResult(ParseSummary(doc)),
|
|
"xpath" => Task.FromResult(EvalXPath(doc, xpath)),
|
|
"to_json" => Task.FromResult(XmlToJson(doc)),
|
|
"format" => Task.FromResult(FormatXml(doc)),
|
|
_ => Task.FromResult(ToolResult.Fail("Unknown action: " + text)),
|
|
};
|
|
if (1 == 0)
|
|
{
|
|
}
|
|
return result;
|
|
}
|
|
catch (XmlException ex)
|
|
{
|
|
return Task.FromResult(ToolResult.Fail("XML 파싱 오류: " + ex.Message));
|
|
}
|
|
catch (Exception ex2)
|
|
{
|
|
return Task.FromResult(ToolResult.Fail("XML 처리 오류: " + ex2.Message));
|
|
}
|
|
}
|
|
|
|
private static ToolResult ParseSummary(XDocument doc)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
StringBuilder stringBuilder2 = stringBuilder;
|
|
StringBuilder stringBuilder3 = stringBuilder2;
|
|
StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(6, 1, stringBuilder2);
|
|
handler.AppendLiteral("Root: ");
|
|
handler.AppendFormatted(doc.Root?.Name.LocalName ?? "(none)");
|
|
stringBuilder3.AppendLine(ref handler);
|
|
if (doc.Root != null)
|
|
{
|
|
XNamespace xNamespace = doc.Root.Name.Namespace;
|
|
if (!string.IsNullOrEmpty(xNamespace.NamespaceName))
|
|
{
|
|
stringBuilder2 = stringBuilder;
|
|
StringBuilder stringBuilder4 = stringBuilder2;
|
|
handler = new StringBuilder.AppendInterpolatedStringHandler(11, 1, stringBuilder2);
|
|
handler.AppendLiteral("Namespace: ");
|
|
handler.AppendFormatted(xNamespace.NamespaceName);
|
|
stringBuilder4.AppendLine(ref handler);
|
|
}
|
|
int value = doc.Descendants().Count();
|
|
int value2 = doc.Descendants().SelectMany((XElement e) => e.Attributes()).Count();
|
|
stringBuilder2 = stringBuilder;
|
|
StringBuilder stringBuilder5 = stringBuilder2;
|
|
handler = new StringBuilder.AppendInterpolatedStringHandler(10, 1, stringBuilder2);
|
|
handler.AppendLiteral("Elements: ");
|
|
handler.AppendFormatted(value);
|
|
stringBuilder5.AppendLine(ref handler);
|
|
stringBuilder2 = stringBuilder;
|
|
StringBuilder stringBuilder6 = stringBuilder2;
|
|
handler = new StringBuilder.AppendInterpolatedStringHandler(12, 1, stringBuilder2);
|
|
handler.AppendLiteral("Attributes: ");
|
|
handler.AppendFormatted(value2);
|
|
stringBuilder6.AppendLine(ref handler);
|
|
List<XElement> list = doc.Root.Elements().Take(20).ToList();
|
|
stringBuilder2 = stringBuilder;
|
|
StringBuilder stringBuilder7 = stringBuilder2;
|
|
handler = new StringBuilder.AppendInterpolatedStringHandler(22, 1, stringBuilder2);
|
|
handler.AppendLiteral("Top-level children (");
|
|
handler.AppendFormatted(doc.Root.Elements().Count());
|
|
handler.AppendLiteral("):");
|
|
stringBuilder7.AppendLine(ref handler);
|
|
foreach (XElement item in list)
|
|
{
|
|
stringBuilder2 = stringBuilder;
|
|
StringBuilder stringBuilder8 = stringBuilder2;
|
|
handler = new StringBuilder.AppendInterpolatedStringHandler(16, 2, stringBuilder2);
|
|
handler.AppendLiteral(" <");
|
|
handler.AppendFormatted(item.Name.LocalName);
|
|
handler.AppendLiteral("> (");
|
|
handler.AppendFormatted(item.Elements().Count());
|
|
handler.AppendLiteral(" children)");
|
|
stringBuilder8.AppendLine(ref handler);
|
|
}
|
|
}
|
|
return ToolResult.Ok(stringBuilder.ToString());
|
|
}
|
|
|
|
private static ToolResult EvalXPath(XDocument doc, string xpath)
|
|
{
|
|
if (string.IsNullOrEmpty(xpath))
|
|
{
|
|
return ToolResult.Fail("XPath 'expression'이 필요합니다.");
|
|
}
|
|
List<XElement> list = doc.XPathSelectElements(xpath).Take(50).ToList();
|
|
if (list.Count == 0)
|
|
{
|
|
return ToolResult.Ok("매칭 노드 없음.");
|
|
}
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
StringBuilder stringBuilder2 = stringBuilder;
|
|
StringBuilder.AppendInterpolatedStringHandler handler = new StringBuilder.AppendInterpolatedStringHandler(8, 1, stringBuilder2);
|
|
handler.AppendLiteral("매칭: ");
|
|
handler.AppendFormatted(list.Count);
|
|
handler.AppendLiteral("개 노드");
|
|
stringBuilder2.AppendLine(ref handler);
|
|
foreach (XElement item in list)
|
|
{
|
|
string text = item.ToString();
|
|
if (text.Length > 500)
|
|
{
|
|
text = text.Substring(0, 500) + "...";
|
|
}
|
|
stringBuilder.AppendLine(text);
|
|
}
|
|
return ToolResult.Ok(stringBuilder.ToString());
|
|
}
|
|
|
|
private static ToolResult XmlToJson(XDocument doc)
|
|
{
|
|
string text = JsonSerializer.Serialize(XmlToDict(doc.Root), new JsonSerializerOptions
|
|
{
|
|
WriteIndented = true
|
|
});
|
|
if (text.Length > 50000)
|
|
{
|
|
text = text.Substring(0, 50000) + "\n... (truncated)";
|
|
}
|
|
return ToolResult.Ok(text);
|
|
}
|
|
|
|
private static Dictionary<string, object?> XmlToDict(XElement el)
|
|
{
|
|
Dictionary<string, object> dictionary = new Dictionary<string, object>();
|
|
foreach (XAttribute item in el.Attributes())
|
|
{
|
|
dictionary["@" + item.Name.LocalName] = item.Value;
|
|
}
|
|
List<IGrouping<string, XElement>> list = (from e in el.Elements()
|
|
group e by e.Name.LocalName).ToList();
|
|
foreach (IGrouping<string, XElement> item2 in list)
|
|
{
|
|
List<XElement> list2 = item2.ToList();
|
|
if (list2.Count == 1)
|
|
{
|
|
XElement xElement = list2[0];
|
|
dictionary[item2.Key] = (xElement.HasElements ? ((IEnumerable)XmlToDict(xElement)) : ((IEnumerable)xElement.Value));
|
|
}
|
|
else
|
|
{
|
|
dictionary[item2.Key] = ((IEnumerable<XElement>)list2).Select((Func<XElement, object>)((XElement c) => c.HasElements ? ((IEnumerable)XmlToDict(c)) : ((IEnumerable)c.Value))).ToList();
|
|
}
|
|
}
|
|
if (!el.HasElements && list.Count == 0 && !string.IsNullOrEmpty(el.Value))
|
|
{
|
|
dictionary["#text"] = el.Value;
|
|
}
|
|
return dictionary;
|
|
}
|
|
|
|
private static ToolResult FormatXml(XDocument doc)
|
|
{
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
using XmlWriter xmlWriter = XmlWriter.Create(stringBuilder, new XmlWriterSettings
|
|
{
|
|
Indent = true,
|
|
IndentChars = " ",
|
|
OmitXmlDeclaration = false
|
|
});
|
|
doc.WriteTo(xmlWriter);
|
|
xmlWriter.Flush();
|
|
string text = stringBuilder.ToString();
|
|
if (text.Length > 50000)
|
|
{
|
|
text = text.Substring(0, 50000) + "\n... (truncated)";
|
|
}
|
|
return ToolResult.Ok(text);
|
|
}
|
|
}
|