405 lines
14 KiB
C#
405 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.IO.Compression;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace AxCopilot.Services.Agent;
|
|
|
|
public static class SkillService
|
|
{
|
|
private static List<SkillDefinition> _skills = new List<SkillDefinition>();
|
|
|
|
private static string _lastFolder = "";
|
|
|
|
private static readonly Dictionary<string, string> ToolNameMap = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
|
|
{
|
|
["Bash"] = "process",
|
|
["bash"] = "process",
|
|
["Read"] = "file_read",
|
|
["Write"] = "file_write",
|
|
["Edit"] = "file_edit",
|
|
["Glob"] = "glob",
|
|
["Grep"] = "grep_tool",
|
|
["WebSearch"] = "http_tool",
|
|
["WebFetch"] = "http_tool",
|
|
["execute_command"] = "process",
|
|
["read_file"] = "file_read",
|
|
["write_file"] = "file_write",
|
|
["edit_file"] = "file_edit",
|
|
["search_files"] = "glob",
|
|
["search_content"] = "grep_tool",
|
|
["list_files"] = "folder_map",
|
|
["shell"] = "process",
|
|
["terminal"] = "process",
|
|
["cat"] = "file_read",
|
|
["find"] = "glob",
|
|
["rg"] = "grep_tool",
|
|
["git"] = "git_tool"
|
|
};
|
|
|
|
public static IReadOnlyList<SkillDefinition> Skills => _skills;
|
|
|
|
public static void LoadSkills(string? customFolder = null)
|
|
{
|
|
List<string> list = new List<string>();
|
|
string text = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "skills");
|
|
if (Directory.Exists(text))
|
|
{
|
|
list.Add(text);
|
|
}
|
|
string text2 = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "AxCopilot", "skills");
|
|
if (Directory.Exists(text2))
|
|
{
|
|
list.Add(text2);
|
|
}
|
|
if (!string.IsNullOrEmpty(customFolder) && Directory.Exists(customFolder))
|
|
{
|
|
list.Add(customFolder);
|
|
}
|
|
List<SkillDefinition> list2 = new List<SkillDefinition>();
|
|
HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
foreach (string item in list)
|
|
{
|
|
string[] files = Directory.GetFiles(item, "*.skill.md");
|
|
foreach (string text3 in files)
|
|
{
|
|
try
|
|
{
|
|
SkillDefinition skillDefinition = ParseSkillFile(text3);
|
|
if (skillDefinition != null && hashSet.Add(skillDefinition.Name))
|
|
{
|
|
list2.Add(skillDefinition);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
LogService.Warn("스킬 로드 실패 [" + text3 + "]: " + ex.Message);
|
|
}
|
|
}
|
|
try
|
|
{
|
|
string[] directories = Directory.GetDirectories(item);
|
|
foreach (string path in directories)
|
|
{
|
|
string text4 = Path.Combine(path, "SKILL.md");
|
|
if (!File.Exists(text4))
|
|
{
|
|
continue;
|
|
}
|
|
try
|
|
{
|
|
SkillDefinition skillDefinition2 = ParseSkillFile(text4);
|
|
if (skillDefinition2 != null && hashSet.Add(skillDefinition2.Name))
|
|
{
|
|
list2.Add(skillDefinition2);
|
|
}
|
|
}
|
|
catch (Exception ex2)
|
|
{
|
|
LogService.Warn("스킬 로드 실패 [" + text4 + "]: " + ex2.Message);
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
foreach (SkillDefinition item2 in list2)
|
|
{
|
|
if (!string.IsNullOrEmpty(item2.Requires))
|
|
{
|
|
IEnumerable<string> source = from r in item2.Requires.Split(',')
|
|
select r.Trim();
|
|
item2.IsAvailable = source.All((string r) => RuntimeDetector.IsAvailable(r));
|
|
}
|
|
}
|
|
_skills = list2;
|
|
_lastFolder = customFolder ?? "";
|
|
int num = list2.Count((SkillDefinition s) => !s.IsAvailable);
|
|
LogService.Info($"스킬 {list2.Count}개 로드 완료" + ((num > 0) ? $" (런타임 미충족 {num}개)" : ""));
|
|
}
|
|
|
|
public static SkillDefinition? Find(string name)
|
|
{
|
|
return _skills.FirstOrDefault((SkillDefinition s) => s.Name.Equals(name, StringComparison.OrdinalIgnoreCase));
|
|
}
|
|
|
|
public static List<SkillDefinition> MatchSlashCommand(string input)
|
|
{
|
|
if (!input.StartsWith('/'))
|
|
{
|
|
return new List<SkillDefinition>();
|
|
}
|
|
return _skills.Where((SkillDefinition s) => ("/" + s.Name).StartsWith(input, StringComparison.OrdinalIgnoreCase)).ToList();
|
|
}
|
|
|
|
public static void EnsureSkillFolder()
|
|
{
|
|
string text = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "AxCopilot", "skills");
|
|
if (!Directory.Exists(text))
|
|
{
|
|
Directory.CreateDirectory(text);
|
|
}
|
|
CreateExampleSkill(text, "daily-standup.skill.md", "daily-standup", "데일리 스탠드업", "작업 폴더의 최근 변경사항을 요약하여 데일리 스탠드업 보고서를 생성합니다.", "작업 폴더의 Git 상태와 최근 커밋을 분석하여 데일리 스탠드업 보고서를 작성하세요.\n\n다음 도구를 사용하세요:\n1. git_tool (action: log, args: \"--oneline -10\") — 최근 커밋 확인\n2. git_tool (action: status) — 현재 변경사항 확인\n3. git_tool (action: diff, args: \"--stat\") — 변경 파일 통계\n\n보고서 형식:\n## \ud83d\udccb 데일리 스탠드업 보고서\n\n### ✅ 완료한 작업\n- 최근 커밋 기반으로 정리\n\n### \ud83d\udd04 진행 중인 작업\n- 현재 수정 중인 파일 기반\n\n### ⚠\ufe0f 블로커/이슈\n- TODO/FIXME가 있으면 표시\n\n한국어로 작성하세요.");
|
|
CreateExampleSkill(text, "bug-hunt.skill.md", "bug-hunt", "버그 탐색", "작업 폴더에서 잠재적 버그 패턴을 검색합니다.", "작업 폴더의 코드에서 잠재적 버그 패턴을 찾아 보고하세요.\n\n다음 도구를 사용하세요:\n1. grep_tool — 위험 패턴 검색:\n - 빈 catch 블록: catch\\s*\\{\\s*\\}\n - TODO/FIXME: (TODO|FIXME|HACK|XXX)\n - .Result/.Wait(): \\.(Result|Wait\\(\\))\n - 하드코딩된 자격증명: (password|secret|apikey)\\s*=\\s*\"\n2. code_review (action: diff_review, focus: bugs) — 최근 변경사항 버그 검사\n\n결과를 심각도별로 분류하여 보고하세요:\n- \ud83d\udd34 CRITICAL: 즉시 수정 필요\n- \ud83d\udfe1 WARNING: 검토 필요\n- \ud83d\udd35 INFO: 개선 권장\n\n한국어로 작성하세요.");
|
|
CreateExampleSkill(text, "code-explain.skill.md", "code-explain", "코드 설명", "지정한 파일의 코드를 상세히 설명합니다.", "사용자가 지정한 파일 또는 작업 폴더의 주요 파일을 읽고 상세히 설명하세요.\n\n다음 도구를 사용하세요:\n1. file_read — 파일 내용 읽기\n2. folder_map — 프로젝트 구조 파악 (필요시)\n\n설명 포함 사항:\n- 파일의 역할과 책임\n- 주요 클래스/함수의 목적\n- 데이터 흐름\n- 외부 의존성\n- 개선 포인트 (있다면)\n\n한국어로 쉽게 설명하세요. 코드 블록을 활용하여 핵심 부분을 인용하세요.");
|
|
}
|
|
|
|
public static string? ExportSkill(SkillDefinition skill, string outputDir)
|
|
{
|
|
try
|
|
{
|
|
if (!File.Exists(skill.FilePath))
|
|
{
|
|
LogService.Warn("스킬 내보내기 실패: 파일 없음 — " + skill.FilePath);
|
|
return null;
|
|
}
|
|
string path = skill.Name + ".skill.zip";
|
|
string text = Path.Combine(outputDir, path);
|
|
if (File.Exists(text))
|
|
{
|
|
File.Delete(text);
|
|
}
|
|
using ZipArchive destination = ZipFile.Open(text, ZipArchiveMode.Create);
|
|
if (skill.IsStandardFormat)
|
|
{
|
|
string directoryName = Path.GetDirectoryName(skill.FilePath);
|
|
if (directoryName != null && Directory.Exists(directoryName))
|
|
{
|
|
string fileName = Path.GetFileName(directoryName);
|
|
foreach (string item in Directory.EnumerateFiles(directoryName, "*", SearchOption.AllDirectories))
|
|
{
|
|
bool flag;
|
|
switch (Path.GetExtension(item).ToLowerInvariant())
|
|
{
|
|
case ".exe":
|
|
case ".dll":
|
|
case ".bat":
|
|
case ".cmd":
|
|
case ".ps1":
|
|
case ".sh":
|
|
flag = true;
|
|
break;
|
|
default:
|
|
flag = false;
|
|
break;
|
|
}
|
|
if (!flag)
|
|
{
|
|
string entryName = fileName + "/" + Path.GetRelativePath(directoryName, item).Replace('\\', '/');
|
|
destination.CreateEntryFromFile(item, entryName, CompressionLevel.Optimal);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
string entryName2 = skill.Name + "/" + Path.GetFileName(skill.FilePath);
|
|
destination.CreateEntryFromFile(skill.FilePath, entryName2, CompressionLevel.Optimal);
|
|
}
|
|
LogService.Info("스킬 내보내기 완료: " + text);
|
|
return text;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
LogService.Warn("스킬 내보내기 실패: " + ex.Message);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static int ImportSkills(string zipPath)
|
|
{
|
|
try
|
|
{
|
|
if (!File.Exists(zipPath))
|
|
{
|
|
LogService.Warn("스킬 가져오기 실패: 파일 없음 — " + zipPath);
|
|
return 0;
|
|
}
|
|
string text = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "AxCopilot", "skills");
|
|
if (!Directory.Exists(text))
|
|
{
|
|
Directory.CreateDirectory(text);
|
|
}
|
|
using ZipArchive zipArchive = ZipFile.OpenRead(zipPath);
|
|
HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { ".exe", ".dll", ".bat", ".cmd", ".ps1", ".sh", ".com", ".scr", ".msi" };
|
|
foreach (ZipArchiveEntry entry in zipArchive.Entries)
|
|
{
|
|
if (hashSet.Contains(Path.GetExtension(entry.Name)))
|
|
{
|
|
LogService.Warn("스킬 가져오기 차단: 실행 가능 파일 포함 — " + entry.FullName);
|
|
return 0;
|
|
}
|
|
}
|
|
List<ZipArchiveEntry> list = zipArchive.Entries.Where((ZipArchiveEntry e) => e.Name.EndsWith(".skill.md", StringComparison.OrdinalIgnoreCase) || e.Name.Equals("SKILL.md", StringComparison.OrdinalIgnoreCase)).ToList();
|
|
if (list.Count == 0)
|
|
{
|
|
LogService.Warn("스킬 가져오기 실패: zip에 .skill.md 또는 SKILL.md 파일 없음");
|
|
return 0;
|
|
}
|
|
int num = 0;
|
|
foreach (ZipArchiveEntry entry2 in zipArchive.Entries)
|
|
{
|
|
if (string.IsNullOrEmpty(entry2.Name))
|
|
{
|
|
continue;
|
|
}
|
|
string text2 = entry2.FullName.Replace('/', Path.DirectorySeparatorChar);
|
|
if (!text2.Contains(".."))
|
|
{
|
|
string text3 = Path.Combine(text, text2);
|
|
string directoryName = Path.GetDirectoryName(text3);
|
|
if (directoryName != null && !Directory.Exists(directoryName))
|
|
{
|
|
Directory.CreateDirectory(directoryName);
|
|
}
|
|
entry2.ExtractToFile(text3, overwrite: true);
|
|
if (entry2.Name.EndsWith(".skill.md", StringComparison.OrdinalIgnoreCase) || entry2.Name.Equals("SKILL.md", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
num++;
|
|
}
|
|
}
|
|
}
|
|
if (num > 0)
|
|
{
|
|
LogService.Info($"스킬 가져오기 완료: {num}개 스킬 ({zipPath})");
|
|
LoadSkills();
|
|
}
|
|
return num;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
LogService.Warn("스킬 가져오기 실패: " + ex.Message);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public static string MapToolNames(string skillBody)
|
|
{
|
|
if (string.IsNullOrEmpty(skillBody))
|
|
{
|
|
return skillBody;
|
|
}
|
|
foreach (KeyValuePair<string, string> item in ToolNameMap)
|
|
{
|
|
skillBody = skillBody.Replace("`" + item.Key + "`", "`" + item.Value + "`");
|
|
skillBody = skillBody.Replace("(" + item.Key + ")", "(" + item.Value + ")");
|
|
}
|
|
return skillBody;
|
|
}
|
|
|
|
private static void CreateExampleSkill(string folder, string fileName, string name, string label, string description, string body)
|
|
{
|
|
string path = Path.Combine(folder, fileName);
|
|
if (!File.Exists(path))
|
|
{
|
|
string text = $"---\nname: {name}\nlabel: {label}\ndescription: {description}\nicon: \\uE768\n---\n\n{body.Trim()}";
|
|
string[] value = (from l in text.Split('\n')
|
|
select l.TrimStart()).ToArray();
|
|
File.WriteAllText(path, string.Join('\n', value), Encoding.UTF8);
|
|
}
|
|
}
|
|
|
|
private static SkillDefinition? ParseSkillFile(string filePath)
|
|
{
|
|
string text = File.ReadAllText(filePath, Encoding.UTF8);
|
|
if (!text.TrimStart().StartsWith("---"))
|
|
{
|
|
return null;
|
|
}
|
|
int num = text.IndexOf("---", StringComparison.Ordinal);
|
|
int num2 = text.IndexOf("---", num + 3, StringComparison.Ordinal);
|
|
if (num2 < 0)
|
|
{
|
|
return null;
|
|
}
|
|
int num3 = num + 3;
|
|
string text2 = text.Substring(num3, num2 - num3).Trim();
|
|
string text3 = text;
|
|
num3 = num2 + 3;
|
|
string skillBody = text3.Substring(num3, text3.Length - num3).Trim();
|
|
Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
|
string text4 = null;
|
|
string[] array = text2.Split('\n');
|
|
foreach (string text5 in array)
|
|
{
|
|
if (text4 != null && (text5.StartsWith(" ") || text5.StartsWith("\t")))
|
|
{
|
|
string text6 = text5.TrimStart();
|
|
int num4 = text6.IndexOf(':');
|
|
if (num4 > 0)
|
|
{
|
|
string text7 = text6.Substring(0, num4).Trim();
|
|
text3 = text6;
|
|
num3 = num4 + 1;
|
|
string value = text3.Substring(num3, text3.Length - num3).Trim().Trim('"', '\'');
|
|
dictionary[text4 + "." + text7] = value;
|
|
}
|
|
continue;
|
|
}
|
|
text4 = null;
|
|
int num5 = text5.IndexOf(':');
|
|
if (num5 > 0)
|
|
{
|
|
string text8 = text5.Substring(0, num5).Trim();
|
|
text3 = text5;
|
|
num3 = num5 + 1;
|
|
string value2 = text3.Substring(num3, text3.Length - num3).Trim().Trim('"', '\'');
|
|
if (string.IsNullOrEmpty(value2))
|
|
{
|
|
text4 = text8;
|
|
}
|
|
else
|
|
{
|
|
dictionary[text8] = value2;
|
|
}
|
|
}
|
|
}
|
|
string fileName = Path.GetFileName(Path.GetDirectoryName(filePath) ?? "");
|
|
string text9 = Path.GetFileNameWithoutExtension(filePath).Replace(".skill", "");
|
|
string defaultValue = (filePath.EndsWith("SKILL.md", StringComparison.OrdinalIgnoreCase) ? fileName : text9);
|
|
string valueOrDefault = dictionary.GetValueOrDefault("name", defaultValue);
|
|
if (string.IsNullOrEmpty(valueOrDefault))
|
|
{
|
|
return null;
|
|
}
|
|
string text10 = dictionary.GetValueOrDefault("label", "") ?? "";
|
|
string value3 = dictionary.GetValueOrDefault("icon", "") ?? "";
|
|
if (string.IsNullOrEmpty(text10) && dictionary.TryGetValue("metadata.label", out var value4))
|
|
{
|
|
text10 = value4 ?? "";
|
|
}
|
|
if (string.IsNullOrEmpty(value3) && dictionary.TryGetValue("metadata.icon", out var value5))
|
|
{
|
|
value3 = value5 ?? "";
|
|
}
|
|
return new SkillDefinition
|
|
{
|
|
Id = valueOrDefault,
|
|
Name = valueOrDefault,
|
|
Label = (string.IsNullOrEmpty(text10) ? valueOrDefault : text10),
|
|
Description = (dictionary.GetValueOrDefault("description", "") ?? ""),
|
|
Icon = (string.IsNullOrEmpty(value3) ? "\ue768" : ConvertUnicodeEscape(value3)),
|
|
SystemPrompt = MapToolNames(skillBody),
|
|
FilePath = filePath,
|
|
License = (dictionary.GetValueOrDefault("license", "") ?? ""),
|
|
Compatibility = (dictionary.GetValueOrDefault("compatibility", "") ?? ""),
|
|
AllowedTools = (dictionary.GetValueOrDefault("allowed-tools", "") ?? ""),
|
|
Requires = (dictionary.GetValueOrDefault("requires", "") ?? ""),
|
|
Tabs = (dictionary.GetValueOrDefault("tabs", "all") ?? "all")
|
|
};
|
|
}
|
|
|
|
private static string ConvertUnicodeEscape(string value)
|
|
{
|
|
if (string.IsNullOrEmpty(value))
|
|
{
|
|
return value;
|
|
}
|
|
return Regex.Replace(value, "\\\\u([0-9a-fA-F]{4})", (Match m) => ((char)Convert.ToInt32(m.Groups[1].Value, 16)).ToString());
|
|
}
|
|
}
|