jp.keijiro.ai.assistant.extensions 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [1.0.1] - 2026-04-24
+
+### Changed
+
+- Reimplemented Conversation Extractor as a Unity Editor window that reads `Logs/relay.txt` and lets you review, copy, and save extracted conversations.
+
 ## [1.0.0] - 2025-04-23
 
 - Initial version.

package/Editor/ConversationExtractorWindow.cs

@@ -0,0 +1,227 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Text.RegularExpressions;
+using UnityEditor;
+using UnityEngine;
+
+namespace AIAssistantExtensions {
+
+class ConversationExtractorWindow : EditorWindow
+{
+    const string RelayLogRelativePath = "Logs/relay.txt";
+
+    static readonly Regex MessageRegex = new(
+      "\"\\$type\":\"(?<type>[^\"]+)\".*?\"message_id\":\"(?<messageId>[^\"]+)\".*?(?:\"last_message\":(?<lastMessage>true|false).*?)?\"markdown\":\"(?<markdown>(?:\\\\.|[^\"\\\\])*)\"",
+      RegexOptions.Compiled);
+
+    Vector2 _scroll;
+    string _markdown;
+    string _status;
+    bool _includeEmpty;
+
+    [MenuItem("Window/AI/Conversation Extractor")]
+    static void Open()
+    {
+        var window = GetWindow<ConversationExtractorWindow>();
+        window.titleContent = new GUIContent("Conversation Extractor");
+        window.minSize = new Vector2(480, 320);
+        window.Extract();
+    }
+
+    void OnGUI()
+    {
+        using (new EditorGUILayout.HorizontalScope(EditorStyles.toolbar))
+        {
+            var includeEmpty = GUILayout.Toggle(_includeEmpty, "Include Empty", EditorStyles.toolbarButton);
+            if (includeEmpty != _includeEmpty) _includeEmpty = includeEmpty;
+
+            GUILayout.FlexibleSpace();
+
+            if (GUILayout.Button("Extract", EditorStyles.toolbarButton))
+                Extract();
+            if (GUILayout.Button("Copy", EditorStyles.toolbarButton))
+                CopyToClipboard();
+            if (GUILayout.Button("Save", EditorStyles.toolbarButton))
+                SaveMarkdown();
+        }
+
+        if (!string.IsNullOrEmpty(_status))
+            EditorGUILayout.HelpBox(_status, MessageType.Info);
+
+        using var scroll = new EditorGUILayout.ScrollViewScope(_scroll);
+        _scroll = scroll.scrollPosition;
+        EditorGUILayout.TextArea(_markdown ?? "", GUILayout.ExpandHeight(true));
+    }
+
+    void Extract()
+    {
+        var path = GetRelayLogPath();
+        if (!File.Exists(path))
+        {
+            _markdown = "";
+            _status = $"Relay log not found: {path}";
+            return;
+        }
+
+        var pairs = ExtractPairs(path);
+        _markdown = BuildMarkdown(pairs, _includeEmpty);
+        _status = $"Extracted {pairs.Count} conversation pair(s) from {RelayLogRelativePath}.";
+    }
+
+    void CopyToClipboard()
+    {
+        EditorGUIUtility.systemCopyBuffer = _markdown ?? "";
+        _status = "Copied extracted markdown to the clipboard.";
+    }
+
+    void SaveMarkdown()
+    {
+        var projectRoot = GetProjectRootPath();
+        var defaultPath = Path.Combine(projectRoot, "Logs", "conversations.md");
+        var path = EditorUtility.SaveFilePanel("Save extracted conversations", Path.GetDirectoryName(defaultPath), Path.GetFileName(defaultPath), "md");
+        if (string.IsNullOrEmpty(path)) return;
+
+        File.WriteAllText(path, _markdown ?? "", Encoding.UTF8);
+        _status = $"Saved extracted markdown to {path}";
+    }
+
+    static List<ConversationPair> ExtractPairs(string path)
+    {
+        var pairs = new List<ConversationPair>();
+        ConversationPair currentPair = null;
+        string activeResponseId = null;
+
+        var lines = File.ReadAllLines(path, Encoding.UTF8);
+        for (var i = 0; i < lines.Length; i++)
+        {
+            var parsed = ParseLine(lines[i]);
+            if (parsed == null) continue;
+
+            if (parsed.Type == "CHAT_ACKNOWLEDGMENT_V1" && !string.IsNullOrWhiteSpace(parsed.Markdown))
+            {
+                if (currentPair != null && currentPair.ResponseParts.Count > 0)
+                    pairs.Add(currentPair);
+
+                currentPair = new ConversationPair(parsed.Markdown.Trim(), i + 1, parsed.MessageId);
+                activeResponseId = null;
+                continue;
+            }
+
+            if (parsed.Type != "CHAT_RESPONSE_V1" || currentPair == null) continue;
+            if (string.IsNullOrEmpty(parsed.Markdown) || parsed.Markdown.StartsWith("<")) continue;
+
+            if (activeResponseId == null)
+            {
+                activeResponseId = parsed.MessageId;
+                currentPair.ResponseMessageId = activeResponseId;
+            }
+
+            if (parsed.MessageId == activeResponseId)
+            {
+                currentPair.ResponseParts.Add(parsed.Markdown);
+                currentPair.ResponseLines.Add(i + 1);
+            }
+
+            if (parsed.LastMessage && parsed.MessageId == activeResponseId)
+            {
+                pairs.Add(currentPair);
+                currentPair = null;
+                activeResponseId = null;
+            }
+        }
+
+        if (currentPair != null)
+            pairs.Add(currentPair);
+
+        return pairs;
+    }
+
+    static ParsedLine ParseLine(string line)
+    {
+        var match = MessageRegex.Match(line);
+        if (!match.Success) return null;
+
+        return new ParsedLine
+        (
+            match.Groups["type"].Value,
+            match.Groups["messageId"].Value,
+            match.Groups["lastMessage"].Value == "true",
+            DecodeMarkdown(match.Groups["markdown"].Value)
+        );
+    }
+
+    static string DecodeMarkdown(string value)
+      => JsonUtility.FromJson<JsonStringWrapper>("{\"value\":\"" + value + "\"}")?.value ?? "";
+
+    static string BuildMarkdown(List<ConversationPair> pairs, bool includeEmpty)
+    {
+        var builder = new StringBuilder();
+
+        foreach (var pair in pairs)
+        {
+            var response = pair.Response.Trim();
+            if (!includeEmpty && string.IsNullOrEmpty(response)) continue;
+
+            if (builder.Length > 0)
+                builder.Append("\n\n");
+
+            builder.Append("## User\n\n");
+            builder.Append(pair.Prompt);
+            builder.Append("\n\n## Assistant\n\n");
+            builder.Append(string.IsNullOrEmpty(response) ? "(No extracted response)" : response);
+        }
+
+        return builder.ToString();
+    }
+
+    static string GetProjectRootPath()
+      => Directory.GetParent(Application.dataPath)?.FullName ?? Directory.GetCurrentDirectory();
+
+    static string GetRelayLogPath()
+      => Path.Combine(GetProjectRootPath(), RelayLogRelativePath);
+
+    [Serializable]
+    class JsonStringWrapper
+    {
+        public string value = "";
+    }
+
+    class ConversationPair
+    {
+        public readonly string Prompt;
+        public readonly int PromptLine;
+        public readonly string PromptMessageId;
+        public readonly List<string> ResponseParts = new();
+        public readonly List<int> ResponseLines = new();
+        public string ResponseMessageId;
+
+        public string Response => string.Concat(ResponseParts);
+
+        public ConversationPair(string prompt, int promptLine, string promptMessageId)
+        {
+            Prompt = prompt;
+            PromptLine = promptLine;
+            PromptMessageId = promptMessageId;
+        }
+    }
+
+    class ParsedLine
+    {
+        public readonly string Type;
+        public readonly string MessageId;
+        public readonly bool LastMessage;
+        public readonly string Markdown;
+
+        public ParsedLine(string type, string messageId, bool lastMessage, string markdown)
+        {
+            Type = type;
+            MessageId = messageId;
+            LastMessage = lastMessage;
+            Markdown = markdown;
+        }
+    }
+}
+
+} // namespace AIAssistantExtensions

package/Editor/ConversationExtractorWindow.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 17b29e54e64e4ff0b5f6fd8fd7b4dc81

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jp.keijiro.ai.assistant.extensions",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "displayName": "AI Assistant Extensions",
   "description": "Custom Unity package that provides extensions for Unity AI Assistant.",
   "unity": "6000.0",
@@ -13,11 +13,11 @@
   "licensesUrl": "https://github.com/keijiro/AIA-Extensions/blob/master/LICENSE",
   "license": "Unlicense",
   "_upm": {
-    "changelog": "- Initial release."
+    "changelog": "- Reimplemented Conversation Extractor as a Unity Editor window that reads `Logs/relay.txt` and lets you review, copy, and save extracted conversations."
   },
   "repository": {
     "url": "git@github.com:keijiro/AIA-Extensions.git",
     "type": "git",
-    "revision": "5972c2dd0d5b6a7ad01c2de12f17396f77b1cfc7"
+    "revision": "56ca9552dd1911766223a864cba2a4267e23cde6"
   }
 }

package/Extras~/extract_conversations.py

@@ -1,127 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import argparse
-import json
-import re
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Optional
-
-
-MESSAGE_RE = re.compile(
-    r'"\$type":"(?P<type>[^"]+)".*?'
-    r'"message_id":"(?P<message_id>[^"]+)".*?'
-    r'(?:"last_message":(?P<last_message>true|false).*?)?'
-    r'"markdown":"(?P<markdown>(?:\\.|[^"\\])*)"',
-)
-
-
-@dataclass
-class ConversationPair:
-    prompt: str
-    prompt_line: int
-    prompt_message_id: str
-    response_parts: list[str] = field(default_factory=list)
-    response_lines: list[int] = field(default_factory=list)
-    response_message_id: Optional[str] = None
-
-    @property
-    def response(self) -> str:
-        return "".join(self.response_parts).strip()
-
-
-def decode_markdown(value: str) -> str:
-    return json.loads(f'"{value}"')
-
-
-def parse_line(line: str):
-    match = MESSAGE_RE.search(line)
-    if not match:
-        return None
-
-    groups = match.groupdict()
-    return {
-        "type": groups["type"],
-        "message_id": groups["message_id"],
-        "last_message": groups["last_message"] == "true",
-        "markdown": decode_markdown(groups["markdown"]),
-    }
-
-
-def extract_pairs(path: Path) -> list[ConversationPair]:
-    pairs: list[ConversationPair] = []
-    current_pair: Optional[ConversationPair] = None
-    active_response_id: Optional[str] = None
-
-    for line_number, raw_line in enumerate(path.read_text(encoding="utf-8").splitlines(), start=1):
-        parsed = parse_line(raw_line)
-        if not parsed:
-            continue
-
-        message_type = parsed["type"]
-        markdown = parsed["markdown"]
-
-        if message_type == "CHAT_ACKNOWLEDGMENT_V1" and markdown:
-            if current_pair and current_pair.response_parts:
-                pairs.append(current_pair)
-
-            current_pair = ConversationPair(
-                prompt=markdown.strip(),
-                prompt_line=line_number,
-                prompt_message_id=parsed["message_id"],
-            )
-            active_response_id = None
-            continue
-
-        if message_type != "CHAT_RESPONSE_V1" or current_pair is None:
-            continue
-
-        if markdown and not markdown.startswith("<"):
-            if active_response_id is None:
-                active_response_id = parsed["message_id"]
-                current_pair.response_message_id = active_response_id
-
-            if parsed["message_id"] == active_response_id:
-                current_pair.response_parts.append(markdown)
-                current_pair.response_lines.append(line_number)
-
-        if parsed["last_message"] and active_response_id == parsed["message_id"]:
-            pairs.append(current_pair)
-            current_pair = None
-            active_response_id = None
-
-    if current_pair:
-        pairs.append(current_pair)
-
-    return pairs
-
-
-def build_markdown(pairs: list[ConversationPair], include_empty: bool) -> str:
-    sections = []
-
-    for pair in pairs:
-        if not include_empty and not pair.response:
-            continue
-
-        response = pair.response or "(No extracted response)"
-        sections.append(f"## User\n\n{pair.prompt}\n\n## Assistant\n\n{response}")
-
-    return "\n\n".join(sections)
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Extract user prompts and natural-language assistant replies from Unity AI relay logs."
-    )
-    parser.add_argument("logfile", nargs="?", default="relay.txt", help="Path to relay log file")
-    parser.add_argument("--include-empty", action="store_true", help="Include prompts without extracted replies")
-    args = parser.parse_args()
-
-    path = Path(args.logfile)
-    pairs = extract_pairs(path)
-    print(build_markdown(pairs, args.include_empty))
-
-
-if __name__ == "__main__":
-    main()