@bonginkan/maria 3.1.4 → 3.1.6

package/dist/bin/maria.cjs

@@ -11757,6 +11757,2522 @@ var init_ai_response_tetris_template = __esm({
   }
 });
 
+// src/services/ai-response/intent.ts
+function analyzeIntent(userInputRaw, recentText = "") {
+  const input3 = userInputRaw.trim();
+  const low = input3.toLowerCase();
+  const combinedContext = (recentText + " " + input3).toLowerCase();
+  if (low.includes("tetris") || input3.includes("\u30C6\u30C8\u30EA\u30B9")) {
+    return {
+      type: "TETRIS_REQUEST",
+      confidence: 0.95,
+      detail: "User explicitly requested Tetris game"
+    };
+  }
+  if (summaryHints.some((hint) => low.includes(hint))) {
+    return {
+      type: "SUMMARIZE",
+      confidence: 0.9,
+      detail: "User wants a summary of the conversation"
+    };
+  }
+  if (recentText && continuationHints.some(
+    (hint) => low.includes(hint) || recentText.toLowerCase().includes(hint)
+  )) {
+    return {
+      type: "CONTINUATION",
+      confidence: 0.85,
+      detail: "User wants to continue previous topic"
+    };
+  }
+  const isQuestion = low.endsWith("?") || low.endsWith("\uFF1F") || jaQuestionStarts.some((w) => input3.startsWith(w)) || [
+    "what",
+    "how",
+    "why",
+    "when",
+    "where",
+    "which",
+    "who",
+    "can you",
+    "could you",
+    "would you",
+    "is it",
+    "are there"
+  ].some((w) => low.startsWith(w));
+  if (isQuestion) {
+    return {
+      type: "QUESTION",
+      confidence: 0.8,
+      detail: "User is asking a question"
+    };
+  }
+  const hasCodeSnippet = input3.includes("```") || input3.includes("`");
+  const hasCodeHint = codeHints.some((hint) => combinedContext.includes(hint));
+  const hasJaCodeTerm = jaCodeTerms.some((term) => input3.includes(term));
+  const hasEnCodeTerms = [
+    "implement",
+    "create",
+    "build",
+    "write",
+    "develop",
+    "code",
+    "function",
+    "class",
+    "method",
+    "component"
+  ].some((w) => low.includes(w));
+  if (hasCodeSnippet || hasCodeHint || hasJaCodeTerm || hasEnCodeTerms) {
+    return {
+      type: "CODE_REQUEST",
+      confidence: hasCodeSnippet ? 0.9 : 0.75,
+      detail: "User wants code implementation or help"
+    };
+  }
+  if (["refactor", "\u30EA\u30D5\u30A1\u30AF\u30BF", "\u6539\u5584", "\u6700\u9069\u5316", "optimize", "improve"].some((w) => low.includes(w))) {
+    return {
+      type: "REFACTOR",
+      confidence: 0.7,
+      detail: "User wants code refactoring or optimization"
+    };
+  }
+  return {
+    type: "GENERAL",
+    confidence: 0.3,
+    detail: "General conversation or unclear intent"
+  };
+}
+function detectLanguage(input3) {
+  const hasJapanese = /[ぁ-んァ-ヶー一-龥]/.test(input3);
+  return hasJapanese ? "ja" : "en";
+}
+var jaQuestionStarts, codeHints, jaCodeTerms, continuationHints, summaryHints;
+var init_intent = __esm({
+  "src/services/ai-response/intent.ts"() {
+    jaQuestionStarts = [
+      "\u4F55",
+      "\u3069\u3046",
+      "\u306A\u305C",
+      "\u3044\u3064",
+      "\u3069\u3053",
+      "\u3069\u308C",
+      "\u8AB0",
+      "\u3067\u304D\u307E\u3059\u304B",
+      "\u6559\u3048\u3066",
+      "\u3042\u308A\u307E\u3059\u304B",
+      "\u3067\u3057\u3087\u3046\u304B"
+    ];
+    codeHints = [
+      "```",
+      "function ",
+      "class ",
+      "const ",
+      "let ",
+      "import ",
+      "export ",
+      ".ts",
+      ".tsx",
+      ".js",
+      ".jsx",
+      ".json",
+      ".py",
+      ".java",
+      ".go",
+      ".rs",
+      "HTML",
+      "CSS",
+      "SQL",
+      "Dockerfile",
+      "yaml",
+      "yml"
+    ];
+    jaCodeTerms = [
+      "\u5B9F\u88C5",
+      "\u30B3\u30FC\u30C9",
+      "\u95A2\u6570",
+      "\u30AF\u30E9\u30B9",
+      "\u30D3\u30EB\u30C9",
+      "\u578B",
+      "\u578B\u5B9A\u7FA9",
+      "\u30C6\u30B9\u30C8",
+      "\u30D7\u30ED\u30B0\u30E9\u30E0",
+      "\u30B9\u30AF\u30EA\u30D7\u30C8",
+      "\u30A2\u30D7\u30EA",
+      "\u958B\u767A"
+    ];
+    continuationHints = [
+      "\u7D9A\u304D",
+      "\u3064\u3065\u304D",
+      "\u7D9A\u884C",
+      "\u5148\u307B\u3069\u306E",
+      "\u524D\u56DE\u306E",
+      "\u3055\u3063\u304D\u306E",
+      "complete",
+      "continue",
+      "start",
+      "give me",
+      "finish",
+      "proceed",
+      "next",
+      "then",
+      "whole code"
+    ];
+    summaryHints = [
+      "\u8981\u7D04",
+      "\u307E\u3068\u3081",
+      "\u30B5\u30DE\u30EA\u30FC",
+      "\u307E\u3068\u3081\u3066",
+      "\u6574\u7406",
+      "summarize",
+      "summary",
+      "recap",
+      "overview"
+    ];
+  }
+});
+
+// src/services/ai-response/providers/base-provider.ts
+var BaseAIProvider2;
+var init_base_provider = __esm({
+  "src/services/ai-response/providers/base-provider.ts"() {
+    BaseAIProvider2 = class {
+      config = {};
+      initialized = false;
+      availableModels = [];
+      async initialize(config2) {
+        this.config = config2;
+        this.initialized = true;
+        await this.performInitialization();
+      }
+      async streamCompletion(request2, onChunk) {
+        const response2 = await this.generateCompletion(request2);
+        const chunks = this.chunkResponse(response2.content);
+        for (const chunk2 of chunks) {
+          onChunk(chunk2);
+          await this.delay(50);
+        }
+        return response2;
+      }
+      isAvailable() {
+        return this.initialized && this.checkAvailability();
+      }
+      getAvailableModels() {
+        return this.availableModels;
+      }
+      /**
+       * Chunk response into smaller pieces for simulated streaming
+       */
+      chunkResponse(text2, chunkSize = 50) {
+        const chunks = [];
+        const words2 = text2.split(" ");
+        for (let i2 = 0; i2 < words2.length; i2 += chunkSize) {
+          chunks.push(words2.slice(i2, i2 + chunkSize).join(" ") + " ");
+        }
+        return chunks;
+      }
+      /**
+       * Utility delay function
+       */
+      delay(ms) {
+        return new Promise((resolve6) => setTimeout(resolve6, ms));
+      }
+      /**
+       * Retry logic for API calls
+       */
+      async withRetry(operation, maxRetries = 3) {
+        let lastError;
+        for (let i2 = 0; i2 < maxRetries; i2++) {
+          try {
+            return await operation();
+          } catch (error2) {
+            lastError = error2;
+            if (this.isNonRetryableError(error2)) {
+              throw error2;
+            }
+            if (i2 < maxRetries - 1) {
+              await this.delay(Math.pow(2, i2) * 1e3);
+            }
+          }
+        }
+        throw lastError || new Error("Operation failed after retries");
+      }
+      /**
+       * Check if error should not be retried
+       */
+      isNonRetryableError(error2) {
+        const message2 = error2?.message?.toLowerCase() || "";
+        return message2.includes("invalid api key") || message2.includes("unauthorized") || message2.includes("forbidden");
+      }
+    };
+  }
+});
+
+// src/services/ai-response/providers/openai-provider.ts
+var OpenAIProvider2;
+var init_openai_provider2 = __esm({
+  "src/services/ai-response/providers/openai-provider.ts"() {
+    init_base_provider();
+    OpenAIProvider2 = class extends BaseAIProvider2 {
+      name = "OpenAI";
+      apiEndpoint = "https://api.openai.com/v1/chat/completions";
+      async performInitialization() {
+        if (!this.config.defaultModel) {
+          this.config.defaultModel = "gpt-3.5-turbo";
+        }
+        this.availableModels = [
+          "gpt-4",
+          "gpt-4-turbo-preview",
+          "gpt-3.5-turbo",
+          "gpt-3.5-turbo-16k"
+        ];
+        if (!this.config.apiKey) {
+          console.warn("[OpenAI Provider] No API key provided - will use template responses");
+        }
+      }
+      checkAvailability() {
+        return true;
+      }
+      async generateCompletion(request2) {
+        if (!this.config.apiKey) {
+          return this.generateTemplateResponse(request2);
+        }
+        try {
+          const response2 = await this.withRetry(
+            () => this.callOpenAIAPI(request2)
+          );
+          return this.parseOpenAIResponse(response2);
+        } catch (error2) {
+          console.error("[OpenAI Provider] API call failed:", error2);
+          return this.generateTemplateResponse(request2);
+        }
+      }
+      async callOpenAIAPI(request2) {
+        const payload = {
+          model: request2.model || this.config.defaultModel,
+          messages: request2.messages,
+          temperature: request2.temperature ?? 0.7,
+          max_tokens: request2.maxTokens ?? 2e3,
+          stream: false
+        };
+        const response2 = await fetch(this.apiEndpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${this.config.apiKey}`
+          },
+          body: JSON.stringify(payload)
+        });
+        if (!response2.ok) {
+          const error2 = await response2.text();
+          throw new Error(`OpenAI API error: ${response2.status} - ${error2}`);
+        }
+        return response2.json();
+      }
+      parseOpenAIResponse(response2) {
+        const choice2 = response2.choices?.[0];
+        if (!choice2) {
+          throw new Error("Invalid OpenAI response format");
+        }
+        return {
+          content: choice2.message?.content || "",
+          model: response2.model || this.config.defaultModel || "gpt-3.5-turbo",
+          usage: response2.usage ? {
+            promptTokens: response2.usage.prompt_tokens,
+            completionTokens: response2.usage.completion_tokens,
+            totalTokens: response2.usage.total_tokens
+          } : void 0,
+          finishReason: choice2.finish_reason
+        };
+      }
+      /**
+       * Generate template response when API is unavailable
+       */
+      generateTemplateResponse(request2) {
+        const lastMessage2 = request2.messages[request2.messages.length - 1];
+        const input3 = lastMessage2?.content || "";
+        const isJapanese = /[ぁ-んァ-ヶー一-龥]/.test(input3);
+        let content2;
+        if (input3.toLowerCase().includes("code") || input3.includes("\u5B9F\u88C5")) {
+          content2 = isJapanese ? `\u30B3\u30FC\u30C9\u306E\u5B9F\u88C5\u306B\u3064\u3044\u3066\u304A\u624B\u4F1D\u3044\u3057\u307E\u3059\u3002
+
+\`\`\`typescript
+// \u30B5\u30F3\u30D7\u30EB\u5B9F\u88C5
+function example() {
+  console.log('Hello World');
+}
+\`\`\`
+
+\u5B9F\u884C\u624B\u9806:
+1. \u30D5\u30A1\u30A4\u30EB\u3092\u4F5C\u6210
+2. \`node example.js\` \u3067\u5B9F\u884C` : `I'll help you with the code implementation.
+
+\`\`\`typescript
+// Sample implementation
+function example() {
+  console.log('Hello World');
+}
+\`\`\`
+
+Run instructions:
+1. Create the file
+2. Run with \`node example.js\``;
+        } else if (input3.includes("?") || input3.includes("\uFF1F")) {
+          content2 = isJapanese ? `\u3054\u8CEA\u554F\u3042\u308A\u304C\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002\u300C${input3.substring(0, 50)}\u300D\u306B\u3064\u3044\u3066\u8AAC\u660E\u3057\u307E\u3059\u3002
+
+\u8A73\u7D30\u306A\u56DE\u7B54\u3092\u3054\u5E0C\u671B\u306E\u5834\u5408\u306F\u3001\u5177\u4F53\u7684\u306A\u70B9\u3092\u304A\u77E5\u3089\u305B\u304F\u3060\u3055\u3044\u3002` : `Great question about "${input3.substring(0, 50)}". Let me explain.
+
+For more details, please specify what aspect you'd like to focus on.`;
+        } else {
+          content2 = isJapanese ? `\u300C${input3.substring(0, 50)}\u300D\u306B\u3064\u3044\u3066\u5BFE\u5FDC\u3044\u305F\u3057\u307E\u3059\u3002
+
+\u6B21\u306E\u30B9\u30C6\u30C3\u30D7:
+1) \u8A73\u7D30\u3092\u78BA\u8A8D
+2) \u5B9F\u88C5\u3092\u958B\u59CB
+3) \u30C6\u30B9\u30C8\u3092\u5B9F\u884C
+
+\u756A\u53F7\u3067\u304A\u9078\u3073\u304F\u3060\u3055\u3044\u3002` : `I'll help you with "${input3.substring(0, 50)}".
+
+Next steps:
+1) Review details
+2) Start implementation
+3) Run tests
+
+Choose a number.`;
+        }
+        return {
+          content: content2,
+          model: "template",
+          usage: {
+            promptTokens: input3.length,
+            completionTokens: content2.length,
+            totalTokens: input3.length + content2.length
+          },
+          finishReason: "stop"
+        };
+      }
+      async streamCompletion(request2, onChunk) {
+        if (!this.config.apiKey) {
+          return super.streamCompletion(request2, onChunk);
+        }
+        try {
+          return super.streamCompletion(request2, onChunk);
+        } catch (error2) {
+          console.error("[OpenAI Provider] Stream failed:", error2);
+          return super.streamCompletion(request2, onChunk);
+        }
+      }
+    };
+  }
+});
+
+// src/services/ai-response/providers/anthropic-provider.ts
+var AnthropicProvider2;
+var init_anthropic_provider2 = __esm({
+  "src/services/ai-response/providers/anthropic-provider.ts"() {
+    init_base_provider();
+    AnthropicProvider2 = class extends BaseAIProvider2 {
+      name = "Anthropic";
+      apiEndpoint = "https://api.anthropic.com/v1/messages";
+      async performInitialization() {
+        if (!this.config.defaultModel) {
+          this.config.defaultModel = "claude-3-sonnet-20240229";
+        }
+        this.availableModels = [
+          "claude-3-opus-20240229",
+          "claude-3-sonnet-20240229",
+          "claude-3-haiku-20240307",
+          "claude-2.1",
+          "claude-instant-1.2"
+        ];
+        if (!this.config.apiKey) {
+          console.warn("[Anthropic Provider] No API key provided - will use template responses");
+        }
+      }
+      checkAvailability() {
+        return true;
+      }
+      async generateCompletion(request2) {
+        if (!this.config.apiKey) {
+          return this.generateTemplateResponse(request2);
+        }
+        try {
+          const response2 = await this.withRetry(
+            () => this.callAnthropicAPI(request2)
+          );
+          return this.parseAnthropicResponse(response2);
+        } catch (error2) {
+          console.error("[Anthropic Provider] API call failed:", error2);
+          return this.generateTemplateResponse(request2);
+        }
+      }
+      async callAnthropicAPI(request2) {
+        const messages2 = request2.messages.map((msg2) => ({
+          role: msg2.role === "system" ? "user" : msg2.role,
+          content: msg2.content
+        }));
+        const systemMessage2 = request2.messages.find((m2) => m2.role === "system");
+        const userMessages = request2.messages.filter((m2) => m2.role !== "system");
+        const payload = {
+          model: request2.model || this.config.defaultModel,
+          messages: userMessages.map((msg2) => ({
+            role: msg2.role === "user" ? "user" : "assistant",
+            content: msg2.content
+          })),
+          max_tokens: request2.maxTokens ?? 2e3,
+          temperature: request2.temperature ?? 0.7,
+          ...systemMessage2 && { system: systemMessage2.content }
+        };
+        const response2 = await fetch(this.apiEndpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "X-API-Key": this.config.apiKey,
+            "anthropic-version": "2023-06-01"
+          },
+          body: JSON.stringify(payload)
+        });
+        if (!response2.ok) {
+          const error2 = await response2.text();
+          throw new Error(`Anthropic API error: ${response2.status} - ${error2}`);
+        }
+        return response2.json();
+      }
+      parseAnthropicResponse(response2) {
+        if (!response2.content || !Array.isArray(response2.content)) {
+          throw new Error("Invalid Anthropic response format");
+        }
+        const textContent = response2.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+        return {
+          content: textContent,
+          model: response2.model || this.config.defaultModel || "claude-3-sonnet",
+          usage: response2.usage ? {
+            promptTokens: response2.usage.input_tokens,
+            completionTokens: response2.usage.output_tokens,
+            totalTokens: response2.usage.input_tokens + response2.usage.output_tokens
+          } : void 0,
+          finishReason: response2.stop_reason
+        };
+      }
+      /**
+       * Generate template response when API is unavailable
+       */
+      generateTemplateResponse(request2) {
+        const lastMessage2 = request2.messages[request2.messages.length - 1];
+        const input3 = lastMessage2?.content || "";
+        const isJapanese = /[ぁ-んァ-ヶー一-龥]/.test(input3);
+        let content2;
+        if (input3.toLowerCase().includes("analyze") || input3.includes("\u5206\u6790")) {
+          content2 = isJapanese ? `\u300C${input3.substring(0, 50)}\u300D\u306E\u5206\u6790\u3092\u884C\u3044\u307E\u3059\u3002
+
+## \u5206\u6790\u7D50\u679C
+
+### 1. \u73FE\u72B6
+- \u30DD\u30A4\u30F3\u30C81
+- \u30DD\u30A4\u30F3\u30C82
+
+### 2. \u8AB2\u984C
+- \u8AB2\u984C1
+- \u8AB2\u984C2
+
+### 3. \u63D0\u6848
+- \u6539\u5584\u68481
+- \u6539\u5584\u68482
+
+\u8A73\u7D30\u306A\u5206\u6790\u304C\u5FC5\u8981\u306A\u5834\u5408\u306F\u304A\u77E5\u3089\u305B\u304F\u3060\u3055\u3044\u3002` : `I'll analyze "${input3.substring(0, 50)}".
+
+## Analysis
+
+### 1. Current State
+- Point 1
+- Point 2
+
+### 2. Issues
+- Issue 1
+- Issue 2
+
+### 3. Recommendations
+- Solution 1
+- Solution 2
+
+Let me know if you need deeper analysis.`;
+        } else if (input3.toLowerCase().includes("explain") || input3.includes("\u8AAC\u660E")) {
+          content2 = isJapanese ? `\u8A73\u3057\u304F\u8AAC\u660E\u3044\u305F\u3057\u307E\u3059\u3002
+
+## \u6982\u8981
+${input3.substring(0, 50)}\u306B\u3064\u3044\u3066\u3001\u4EE5\u4E0B\u306E\u89B3\u70B9\u304B\u3089\u8AAC\u660E\u3057\u307E\u3059\uFF1A
+
+1. **\u57FA\u672C\u6982\u5FF5**
+   - \u5B9A\u7FA9\u3068\u80CC\u666F
+   - \u91CD\u8981\u6027
+
+2. **\u5B9F\u88C5\u8A73\u7D30**
+   - \u5177\u4F53\u7684\u306A\u624B\u9806
+   - \u30D9\u30B9\u30C8\u30D7\u30E9\u30AF\u30C6\u30A3\u30B9
+
+3. **\u6CE8\u610F\u70B9**
+   - \u3088\u304F\u3042\u308B\u9593\u9055\u3044
+   - \u56DE\u907F\u65B9\u6CD5
+
+\u3055\u3089\u306B\u8A73\u3057\u3044\u60C5\u5831\u304C\u5FC5\u8981\u3067\u3057\u3087\u3046\u304B\uFF1F` : `Let me explain in detail.
+
+## Overview
+Regarding "${input3.substring(0, 50)}", I'll cover:
+
+1. **Core Concepts**
+   - Definition and background
+   - Importance
+
+2. **Implementation Details**
+   - Step-by-step process
+   - Best practices
+
+3. **Considerations**
+   - Common pitfalls
+   - How to avoid them
+
+Would you like more specific information?`;
+        } else {
+          content2 = isJapanese ? `\u627F\u77E5\u3044\u305F\u3057\u307E\u3057\u305F\u3002\u300C${input3.substring(0, 50)}\u300D\u306B\u3064\u3044\u3066\u5BFE\u5FDC\u3057\u307E\u3059\u3002
+
+\u69CB\u9020\u7684\u306B\u30A2\u30D7\u30ED\u30FC\u30C1\u3059\u308B\u305F\u3081\u3001\u4EE5\u4E0B\u306E\u624B\u9806\u3092\u63D0\u6848\u3057\u307E\u3059\uFF1A
+
+1. **\u8981\u4EF6\u306E\u660E\u78BA\u5316**
+2. **\u5B9F\u88C5\u8A08\u753B\u306E\u7B56\u5B9A**
+3. **\u6BB5\u968E\u7684\u306A\u5B9F\u88C5**
+4. **\u30C6\u30B9\u30C8\u3068\u691C\u8A3C**
+
+\u3069\u306E\u6BB5\u968E\u304B\u3089\u59CB\u3081\u307E\u3057\u3087\u3046\u304B\uFF1F` : `I understand. I'll help with "${input3.substring(0, 50)}".
+
+For a structured approach, I suggest:
+
+1. **Clarify requirements**
+2. **Create implementation plan**
+3. **Phased implementation**
+4. **Testing and validation**
+
+Which phase shall we start with?`;
+        }
+        return {
+          content: content2,
+          model: "template-claude",
+          usage: {
+            promptTokens: input3.length,
+            completionTokens: content2.length,
+            totalTokens: input3.length + content2.length
+          },
+          finishReason: "stop"
+        };
+      }
+    };
+  }
+});
+
+// src/services/ai-response/providers/template-provider.ts
+var TemplateProvider;
+var init_template_provider = __esm({
+  "src/services/ai-response/providers/template-provider.ts"() {
+    init_base_provider();
+    TemplateProvider = class extends BaseAIProvider2 {
+      name = "Template";
+      async performInitialization() {
+        this.availableModels = ["template-v1"];
+      }
+      checkAvailability() {
+        return true;
+      }
+      async generateCompletion(request2) {
+        const lastMessage2 = request2.messages[request2.messages.length - 1];
+        const input3 = lastMessage2?.content || "";
+        const context2 = request2.messages.slice(-5).map((m2) => m2.content).join("\n");
+        const isJapanese = /[ぁ-んァ-ヶー一-龥]/.test(input3);
+        const intent2 = this.analyzeIntent(input3, context2);
+        const content2 = this.generateTemplateByIntent(intent2, input3, isJapanese);
+        return {
+          content: content2,
+          model: "template-v1",
+          usage: {
+            promptTokens: input3.length,
+            completionTokens: content2.length,
+            totalTokens: input3.length + content2.length
+          },
+          finishReason: "stop"
+        };
+      }
+      analyzeIntent(input3, context2) {
+        const lower = input3.toLowerCase();
+        const combined = (context2 + " " + input3).toLowerCase();
+        if (lower.includes("implement") || lower.includes("\u5B9F\u88C5")) {
+          return "implementation";
+        }
+        if (lower.includes("debug") || lower.includes("error") || lower.includes("\u30A8\u30E9\u30FC")) {
+          return "debugging";
+        }
+        if (lower.includes("explain") || lower.includes("\u8AAC\u660E")) {
+          return "explanation";
+        }
+        if (lower.includes("?") || lower.includes("\uFF1F")) {
+          return "question";
+        }
+        if (combined.includes("continue") || combined.includes("\u7D9A")) {
+          return "continuation";
+        }
+        if (lower.includes("test") || lower.includes("\u30C6\u30B9\u30C8")) {
+          return "testing";
+        }
+        if (lower.includes("optimize") || lower.includes("\u6700\u9069\u5316")) {
+          return "optimization";
+        }
+        return "general";
+      }
+      generateTemplateByIntent(intent2, input3, isJapanese) {
+        const cleanInput = input3.substring(0, 80);
+        switch (intent2) {
+          case "implementation":
+            return this.generateImplementationTemplate(cleanInput, isJapanese);
+          case "debugging":
+            return this.generateDebuggingTemplate(cleanInput, isJapanese);
+          case "explanation":
+            return this.generateExplanationTemplate(cleanInput, isJapanese);
+          case "question":
+            return this.generateQuestionTemplate(cleanInput, isJapanese);
+          case "continuation":
+            return this.generateContinuationTemplate(cleanInput, isJapanese);
+          case "testing":
+            return this.generateTestingTemplate(cleanInput, isJapanese);
+          case "optimization":
+            return this.generateOptimizationTemplate(cleanInput, isJapanese);
+          default:
+            return this.generateGeneralTemplate(cleanInput, isJapanese);
+        }
+      }
+      generateImplementationTemplate(input3, isJapanese) {
+        return isJapanese ? `\u300C${input3}\u300D\u306E\u5B9F\u88C5\u3092\u958B\u59CB\u3057\u307E\u3059\u3002
+
+## \u5B9F\u88C5\u8A08\u753B
+
+### 1. \u30A2\u30FC\u30AD\u30C6\u30AF\u30C1\u30E3\u8A2D\u8A08
+- \u30B3\u30F3\u30DD\u30FC\u30CD\u30F3\u30C8\u69CB\u9020
+- \u30C7\u30FC\u30BF\u30D5\u30ED\u30FC
+- \u30A8\u30E9\u30FC\u30CF\u30F3\u30C9\u30EA\u30F3\u30B0
+
+### 2. \u57FA\u672C\u5B9F\u88C5
+\`\`\`typescript
+// \u30B5\u30F3\u30D7\u30EB\u5B9F\u88C5
+class Implementation {
+  constructor(private config: Config) {}
+  
+  async execute(): Promise<Result> {
+    // \u5B9F\u88C5\u30ED\u30B8\u30C3\u30AF
+    return this.process();
+  }
+}
+\`\`\`
+
+### 3. \u5B9F\u884C\u624B\u9806
+1. \u4F9D\u5B58\u95A2\u4FC2\u3092\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB: \`pnpm install\`
+2. \u30D3\u30EB\u30C9: \`pnpm build\`
+3. \u30C6\u30B9\u30C8\u5B9F\u884C: \`pnpm test\`
+
+\u6B21\u306E\u30B9\u30C6\u30C3\u30D7\u3092\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044\uFF1A
+1) \u30A8\u30E9\u30FC\u30CF\u30F3\u30C9\u30EA\u30F3\u30B0\u3092\u8FFD\u52A0
+2) \u30C6\u30B9\u30C8\u30B1\u30FC\u30B9\u3092\u4F5C\u6210
+3) \u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9\u6700\u9069\u5316` : `I'll implement "${input3}".
+
+## Implementation Plan
+
+### 1. Architecture Design
+- Component structure
+- Data flow
+- Error handling
+
+### 2. Base Implementation
+\`\`\`typescript
+// Sample implementation
+class Implementation {
+  constructor(private config: Config) {}
+  
+  async execute(): Promise<Result> {
+    // Implementation logic
+    return this.process();
+  }
+}
+\`\`\`
+
+### 3. Run Instructions
+1. Install dependencies: \`npm install\`
+2. Build: \`npm run build\`
+3. Run tests: \`npm test\`
+
+Choose next step:
+1) Add error handling
+2) Create test cases
+3) Optimize performance`;
+      }
+      generateDebuggingTemplate(input3, isJapanese) {
+        return isJapanese ? `\u300C${input3}\u300D\u306E\u30C7\u30D0\u30C3\u30B0\u3092\u652F\u63F4\u3057\u307E\u3059\u3002
+
+## \u30C7\u30D0\u30C3\u30B0\u624B\u9806
+
+### 1. \u554F\u984C\u306E\u7279\u5B9A
+- \u30A8\u30E9\u30FC\u30E1\u30C3\u30BB\u30FC\u30B8\u306E\u78BA\u8A8D
+- \u30B9\u30BF\u30C3\u30AF\u30C8\u30EC\u30FC\u30B9\u306E\u5206\u6790
+- \u518D\u73FE\u6761\u4EF6\u306E\u78BA\u8A8D
+
+### 2. \u4E00\u822C\u7684\u306A\u539F\u56E0
+- \u578B\u306E\u4E0D\u4E00\u81F4
+- Null/Undefined\u53C2\u7167
+- \u975E\u540C\u671F\u51E6\u7406\u306E\u554F\u984C
+- \u4F9D\u5B58\u95A2\u4FC2\u306E\u4E0D\u8DB3
+
+### 3. \u89E3\u6C7A\u7B56
+\`\`\`typescript
+// \u30C7\u30D0\u30C3\u30B0\u30B3\u30FC\u30C9\u4F8B
+try {
+  // \u554F\u984C\u306E\u3042\u308B\u30B3\u30FC\u30C9
+  const result = await operation();
+  console.log('Success:', result);
+} catch (error) {
+  console.error('Error details:', error);
+  // \u30A8\u30E9\u30FC\u51E6\u7406
+}
+\`\`\`
+
+\u6B21\u306E\u78BA\u8A8D\u4E8B\u9805\uFF1A
+1) \u30B3\u30F3\u30BD\u30FC\u30EB\u30ED\u30B0\u3092\u78BA\u8A8D
+2) \u30D6\u30EC\u30FC\u30AF\u30DD\u30A4\u30F3\u30C8\u3092\u8A2D\u5B9A
+3) \u5358\u4F53\u30C6\u30B9\u30C8\u3092\u5B9F\u884C` : `I'll help debug "${input3}".
+
+## Debug Process
+
+### 1. Problem Identification
+- Check error messages
+- Analyze stack trace
+- Verify reproduction steps
+
+### 2. Common Causes
+- Type mismatches
+- Null/Undefined references
+- Async handling issues
+- Missing dependencies
+
+### 3. Solution
+\`\`\`typescript
+// Debug code example
+try {
+  // Problematic code
+  const result = await operation();
+  console.log('Success:', result);
+} catch (error) {
+  console.error('Error details:', error);
+  // Error handling
+}
+\`\`\`
+
+Next checks:
+1) Review console logs
+2) Set breakpoints
+3) Run unit tests`;
+      }
+      generateExplanationTemplate(input3, isJapanese) {
+        return isJapanese ? `\u300C${input3}\u300D\u306B\u3064\u3044\u3066\u8A73\u3057\u304F\u8AAC\u660E\u3057\u307E\u3059\u3002
+
+## \u6982\u8981
+\u3053\u306E\u6982\u5FF5\u306F\u3001\u30BD\u30D5\u30C8\u30A6\u30A7\u30A2\u958B\u767A\u306B\u304A\u3044\u3066\u91CD\u8981\u306A\u5F79\u5272\u3092\u679C\u305F\u3057\u307E\u3059\u3002
+
+## \u8A73\u7D30\u8AAC\u660E
+
+### \u57FA\u672C\u539F\u7406
+- \u30B3\u30A2\u30B3\u30F3\u30BB\u30D7\u30C8
+- \u52D5\u4F5C\u539F\u7406
+- \u5229\u7528\u30B7\u30FC\u30F3
+
+### \u5B9F\u88C5\u4F8B
+\`\`\`typescript
+// \u6982\u5FF5\u306E\u5B9F\u88C5\u4F8B
+const example = {
+  property: 'value',
+  method: () => 'result'
+};
+\`\`\`
+
+### \u30E1\u30EA\u30C3\u30C8\u30FB\u30C7\u30E1\u30EA\u30C3\u30C8
+**\u30E1\u30EA\u30C3\u30C8:**
+- \u52B9\u7387\u7684\u306A\u51E6\u7406
+- \u4FDD\u5B88\u6027\u306E\u5411\u4E0A
+
+**\u30C7\u30E1\u30EA\u30C3\u30C8:**
+- \u5B66\u7FD2\u30B3\u30B9\u30C8
+- \u521D\u671F\u8A2D\u5B9A\u306E\u8907\u96D1\u3055
+
+\u3055\u3089\u306B\u8A73\u3057\u304F\u77E5\u308A\u305F\u3044\u70B9\u306F\u3042\u308A\u307E\u3059\u304B\uFF1F` : `Let me explain "${input3}" in detail.
+
+## Overview
+This concept plays an important role in software development.
+
+## Detailed Explanation
+
+### Core Principles
+- Core concepts
+- How it works
+- Use cases
+
+### Implementation Example
+\`\`\`typescript
+// Concept implementation
+const example = {
+  property: 'value',
+  method: () => 'result'
+};
+\`\`\`
+
+### Pros and Cons
+**Pros:**
+- Efficient processing
+- Better maintainability
+
+**Cons:**
+- Learning curve
+- Initial setup complexity
+
+Would you like to know more?`;
+      }
+      generateQuestionTemplate(input3, isJapanese) {
+        return isJapanese ? `\u3054\u8CEA\u554F\u300C${input3}\u300D\u306B\u304A\u7B54\u3048\u3057\u307E\u3059\u3002
+
+## \u56DE\u7B54
+
+\u7C21\u6F54\u306B\u7B54\u3048\u308B\u3068\u3001\u3053\u308C\u306F\u72B6\u6CC1\u3084\u8981\u4EF6\u306B\u3088\u3063\u3066\u7570\u306A\u308A\u307E\u3059\u3002
+
+### \u8A73\u7D30\u306A\u56DE\u7B54
+
+1. **\u6280\u8853\u7684\u89B3\u70B9**
+   - \u5B9F\u88C5\u306E\u8907\u96D1\u3055
+   - \u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9\u3078\u306E\u5F71\u97FF
+
+2. **\u5B9F\u7528\u7684\u89B3\u70B9**
+   - \u4F7F\u7528\u983B\u5EA6
+   - \u30E1\u30F3\u30C6\u30CA\u30F3\u30B9\u6027
+
+3. **\u30D9\u30B9\u30C8\u30D7\u30E9\u30AF\u30C6\u30A3\u30B9**
+   - \u63A8\u5968\u3055\u308C\u308B\u65B9\u6CD5
+   - \u907F\u3051\u308B\u3079\u304D\u30D1\u30BF\u30FC\u30F3
+
+### \u95A2\u9023\u60C5\u5831
+- \u53C2\u8003\u3068\u306A\u308B\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8
+- \u985E\u4F3C\u306E\u554F\u984C\u3068\u89E3\u6C7A\u7B56
+
+\u4ED6\u306B\u78BA\u8A8D\u3057\u305F\u3044\u70B9\u306F\u3042\u308A\u307E\u3059\u304B\uFF1F` : `I'll answer your question: "${input3}"
+
+## Answer
+
+In brief, this depends on the specific situation and requirements.
+
+### Detailed Response
+
+1. **Technical Perspective**
+   - Implementation complexity
+   - Performance impact
+
+2. **Practical Perspective**
+   - Usage frequency
+   - Maintainability
+
+3. **Best Practices**
+   - Recommended approaches
+   - Patterns to avoid
+
+### Related Information
+- Reference documentation
+- Similar issues and solutions
+
+Any other questions?`;
+      }
+      generateContinuationTemplate(input3, isJapanese) {
+        return isJapanese ? `\u524D\u56DE\u306E\u7D9A\u304D\u304B\u3089\u9032\u3081\u307E\u3059\u3002
+
+## \u9032\u884C\u72B6\u6CC1
+\u3053\u308C\u307E\u3067\u306E\u4F5C\u696D\u3092\u78BA\u8A8D\u3057\u307E\u3057\u305F\u3002
+
+## \u6B21\u306E\u30B9\u30C6\u30C3\u30D7
+
+\u4EE5\u4E0B\u304B\u3089\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044\uFF1A
+
+1) **\u5B9F\u88C5\u3092\u7D99\u7D9A**
+   - \u6B8B\u308A\u306E\u6A5F\u80FD\u3092\u5B9F\u88C5
+   - \u30A8\u30C3\u30B8\u30B1\u30FC\u30B9\u306E\u51E6\u7406
+
+2) **\u30C6\u30B9\u30C8\u3092\u8FFD\u52A0**
+   - \u30E6\u30CB\u30C3\u30C8\u30C6\u30B9\u30C8
+   - \u7D71\u5408\u30C6\u30B9\u30C8
+
+3) **\u30EA\u30D5\u30A1\u30AF\u30BF\u30EA\u30F3\u30B0**
+   - \u30B3\u30FC\u30C9\u306E\u6574\u7406
+   - \u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9\u6539\u5584
+
+4) **\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8\u4F5C\u6210**
+   - API\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8
+   - \u4F7F\u7528\u4F8B\u306E\u8FFD\u52A0
+
+\u756A\u53F7\u3067\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044\uFF081-4\uFF09\u3002` : `Let's continue from where we left off.
+
+## Progress
+I've reviewed our previous work.
+
+## Next Steps
+
+Please choose:
+
+1) **Continue Implementation**
+   - Remaining features
+   - Edge case handling
+
+2) **Add Tests**
+   - Unit tests
+   - Integration tests
+
+3) **Refactoring**
+   - Code organization
+   - Performance improvements
+
+4) **Documentation**
+   - API documentation
+   - Usage examples
+
+Choose a number (1-4).`;
+      }
+      generateTestingTemplate(input3, isJapanese) {
+        return isJapanese ? `\u300C${input3}\u300D\u306E\u30C6\u30B9\u30C8\u3092\u4F5C\u6210\u3057\u307E\u3059\u3002
+
+## \u30C6\u30B9\u30C8\u6226\u7565
+
+### \u30E6\u30CB\u30C3\u30C8\u30C6\u30B9\u30C8
+\`\`\`typescript
+describe('Component', () => {
+  it('should work correctly', () => {
+    const result = component.method();
+    expect(result).toBe(expected);
+  });
+  
+  it('should handle errors', () => {
+    expect(() => component.invalid()).toThrow();
+  });
+});
+\`\`\`
+
+### \u7D71\u5408\u30C6\u30B9\u30C8
+- API \u30A8\u30F3\u30C9\u30DD\u30A4\u30F3\u30C8\u306E\u30C6\u30B9\u30C8
+- \u30C7\u30FC\u30BF\u30D9\u30FC\u30B9\u63A5\u7D9A\u306E\u30C6\u30B9\u30C8
+- \u5916\u90E8\u30B5\u30FC\u30D3\u30B9\u3068\u306E\u9023\u643A\u30C6\u30B9\u30C8
+
+### \u5B9F\u884C\u30B3\u30DE\u30F3\u30C9
+- \`pnpm test\` - \u5168\u30C6\u30B9\u30C8\u5B9F\u884C
+- \`pnpm test:watch\` - \u30A6\u30A9\u30C3\u30C1\u30E2\u30FC\u30C9
+- \`pnpm test:coverage\` - \u30AB\u30D0\u30EC\u30C3\u30B8\u30EC\u30DD\u30FC\u30C8
+
+\u30C6\u30B9\u30C8\u30B1\u30FC\u30B9\u3092\u8FFD\u52A0\u3057\u307E\u3059\u304B\uFF1F` : `I'll create tests for "${input3}".
+
+## Test Strategy
+
+### Unit Tests
+\`\`\`typescript
+describe('Component', () => {
+  it('should work correctly', () => {
+    const result = component.method();
+    expect(result).toBe(expected);
+  });
+  
+  it('should handle errors', () => {
+    expect(() => component.invalid()).toThrow();
+  });
+});
+\`\`\`
+
+### Integration Tests
+- API endpoint tests
+- Database connection tests
+- External service integration
+
+### Run Commands
+- \`npm test\` - Run all tests
+- \`npm test:watch\` - Watch mode
+- \`npm test:coverage\` - Coverage report
+
+Add more test cases?`;
+      }
+      generateOptimizationTemplate(input3, isJapanese) {
+        return isJapanese ? `\u300C${input3}\u300D\u306E\u6700\u9069\u5316\u3092\u884C\u3044\u307E\u3059\u3002
+
+## \u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9\u5206\u6790
+
+### \u73FE\u72B6\u306E\u8AB2\u984C
+- \u51E6\u7406\u6642\u9593: ~500ms
+- \u30E1\u30E2\u30EA\u4F7F\u7528\u91CF: ~50MB
+- CPU\u4F7F\u7528\u7387: \u9AD8
+
+### \u6700\u9069\u5316\u6226\u7565
+
+1. **\u30A2\u30EB\u30B4\u30EA\u30BA\u30E0\u306E\u6539\u5584**
+\`\`\`typescript
+// Before: O(n\xB2)
+for (let i = 0; i < n; i++) {
+  for (let j = 0; j < n; j++) {
+    // \u51E6\u7406
+  }
+}
+
+// After: O(n log n)
+items.sort((a, b) => a - b);
+// \u52B9\u7387\u7684\u306A\u51E6\u7406
+\`\`\`
+
+2. **\u30AD\u30E3\u30C3\u30B7\u30F3\u30B0**
+- \u30E1\u30E2\u30EA\u30AD\u30E3\u30C3\u30B7\u30E5\u306E\u5B9F\u88C5
+- \u8A08\u7B97\u7D50\u679C\u306E\u518D\u5229\u7528
+
+3. **\u975E\u540C\u671F\u51E6\u7406**
+- \u4E26\u5217\u51E6\u7406\u306E\u6D3B\u7528
+- \u30D0\u30C3\u30C1\u51E6\u7406\u306E\u5B9F\u88C5
+
+\u6539\u5584\u52B9\u679C\u3092\u6E2C\u5B9A\u3057\u307E\u3059\u304B\uFF1F` : `I'll optimize "${input3}".
+
+## Performance Analysis
+
+### Current Issues
+- Processing time: ~500ms
+- Memory usage: ~50MB
+- CPU usage: High
+
+### Optimization Strategy
+
+1. **Algorithm Improvement**
+\`\`\`typescript
+// Before: O(n\xB2)
+for (let i = 0; i < n; i++) {
+  for (let j = 0; j < n; j++) {
+    // Process
+  }
+}
+
+// After: O(n log n)
+items.sort((a, b) => a - b);
+// Efficient processing
+\`\`\`
+
+2. **Caching**
+- Memory cache implementation
+- Result reuse
+
+3. **Async Processing**
+- Parallel processing
+- Batch processing
+
+Measure improvements?`;
+      }
+      generateGeneralTemplate(input3, isJapanese) {
+        return isJapanese ? `\u300C${input3}\u300D\u306B\u3064\u3044\u3066\u5BFE\u5FDC\u3044\u305F\u3057\u307E\u3059\u3002
+
+\u3054\u8981\u671B\u3092\u6B63\u3057\u304F\u7406\u89E3\u3059\u308B\u305F\u3081\u3001\u4EE5\u4E0B\u304B\u3089\u6700\u3082\u8FD1\u3044\u3082\u306E\u3092\u304A\u9078\u3073\u304F\u3060\u3055\u3044\uFF1A
+
+1) **\u30B3\u30FC\u30C9\u5B9F\u88C5**
+   - \u65B0\u6A5F\u80FD\u306E\u958B\u767A
+   - \u65E2\u5B58\u30B3\u30FC\u30C9\u306E\u4FEE\u6B63
+
+2) **\u554F\u984C\u89E3\u6C7A**
+   - \u30D0\u30B0\u4FEE\u6B63
+   - \u30A8\u30E9\u30FC\u5BFE\u5FDC
+
+3) **\u8A2D\u8A08\u76F8\u8AC7**
+   - \u30A2\u30FC\u30AD\u30C6\u30AF\u30C1\u30E3\u8A2D\u8A08
+   - \u30D9\u30B9\u30C8\u30D7\u30E9\u30AF\u30C6\u30A3\u30B9
+
+4) **\u5B66\u7FD2\u30B5\u30DD\u30FC\u30C8**
+   - \u6982\u5FF5\u306E\u8AAC\u660E
+   - \u4F7F\u7528\u65B9\u6CD5\u306E\u89E3\u8AAC
+
+\u756A\u53F7\u3067\u304A\u7B54\u3048\u304F\u3060\u3055\u3044\uFF081-4\uFF09\u3002` : `I'll help with "${input3}".
+
+To better understand your needs, please choose:
+
+1) **Code Implementation**
+   - New features
+   - Code modifications
+
+2) **Problem Solving**
+   - Bug fixes
+   - Error resolution
+
+3) **Design Consultation**
+   - Architecture design
+   - Best practices
+
+4) **Learning Support**
+   - Concept explanation
+   - Usage guidance
+
+Please reply with a number (1-4).`;
+      }
+    };
+  }
+});
+
+// src/services/ai-response/providers/provider-factory.ts
+var AIProviderFactory;
+var init_provider_factory = __esm({
+  "src/services/ai-response/providers/provider-factory.ts"() {
+    init_openai_provider2();
+    init_anthropic_provider2();
+    init_template_provider();
+    AIProviderFactory = class _AIProviderFactory {
+      static instance;
+      providers = /* @__PURE__ */ new Map();
+      currentProvider = "template";
+      constructor() {
+      }
+      static getInstance() {
+        if (!_AIProviderFactory.instance) {
+          _AIProviderFactory.instance = new _AIProviderFactory();
+        }
+        return _AIProviderFactory.instance;
+      }
+      /**
+       * Initialize a provider with configuration
+       */
+      async initializeProvider(type2, config2) {
+        const provider2 = this.createProvider(type2);
+        await provider2.initialize(config2);
+        this.providers.set(type2, provider2);
+        console.log(`[Provider Factory] Initialized ${type2} provider`);
+      }
+      /**
+       * Create a provider instance
+       */
+      createProvider(type2) {
+        switch (type2) {
+          case "openai":
+            return new OpenAIProvider2();
+          case "anthropic":
+            return new AnthropicProvider2();
+          case "template":
+            return new TemplateProvider();
+          default:
+            console.warn(`[Provider Factory] Unknown provider type: ${type2}, falling back to template`);
+            return new TemplateProvider();
+        }
+      }
+      /**
+       * Get a specific provider
+       */
+      getProvider(type2) {
+        const targetType = type2 || this.currentProvider;
+        if (!this.providers.has(targetType) && targetType === "template") {
+          const templateProvider = new TemplateProvider();
+          templateProvider.initialize({}).catch(console.error);
+          this.providers.set("template", templateProvider);
+        }
+        return this.providers.get(targetType);
+      }
+      /**
+       * Get the active provider with fallback
+       */
+      async getActiveProvider() {
+        let provider2 = this.getProvider(this.currentProvider);
+        if (provider2?.isAvailable()) {
+          return provider2;
+        }
+        const fallbackOrder = ["openai", "anthropic", "template"];
+        for (const type2 of fallbackOrder) {
+          provider2 = this.getProvider(type2);
+          if (provider2?.isAvailable()) {
+            console.log(`[Provider Factory] Falling back to ${type2} provider`);
+            this.currentProvider = type2;
+            return provider2;
+          }
+        }
+        console.log("[Provider Factory] Using template provider as last resort");
+        const templateProvider = new TemplateProvider();
+        await templateProvider.initialize({});
+        this.providers.set("template", templateProvider);
+        this.currentProvider = "template";
+        return templateProvider;
+      }
+      /**
+       * Set the active provider
+       */
+      setActiveProvider(type2) {
+        if (!this.providers.has(type2)) {
+          throw new Error(`Provider ${type2} not initialized`);
+        }
+        this.currentProvider = type2;
+        console.log(`[Provider Factory] Active provider set to ${type2}`);
+      }
+      /**
+       * Initialize providers from environment variables
+       */
+      async initializeFromEnvironment() {
+        const configs = [];
+        if (process.env.OPENAI_API_KEY) {
+          configs.push(["openai", {
+            apiKey: process.env.OPENAI_API_KEY,
+            defaultModel: process.env.OPENAI_MODEL || "gpt-3.5-turbo"
+          }]);
+        }
+        if (process.env.ANTHROPIC_API_KEY) {
+          configs.push(["anthropic", {
+            apiKey: process.env.ANTHROPIC_API_KEY,
+            defaultModel: process.env.ANTHROPIC_MODEL || "claude-3-sonnet-20240229"
+          }]);
+        }
+        configs.push(["template", {}]);
+        for (const [type2, config2] of configs) {
+          try {
+            await this.initializeProvider(type2, config2);
+          } catch (error2) {
+            console.error(`[Provider Factory] Failed to initialize ${type2}:`, error2);
+          }
+        }
+        const preferredProvider = process.env.AI_PROVIDER || "template";
+        if (this.providers.has(preferredProvider)) {
+          this.setActiveProvider(preferredProvider);
+        }
+      }
+      /**
+       * Get list of available providers
+       */
+      getAvailableProviders() {
+        return Array.from(this.providers.keys()).filter((type2) => {
+          const provider2 = this.providers.get(type2);
+          return provider2?.isAvailable();
+        });
+      }
+      /**
+       * Clear all providers (for testing)
+       */
+      clearProviders() {
+        this.providers.clear();
+        this.currentProvider = "template";
+      }
+    };
+  }
+});
+
+// src/services/ai-response/feature-flags.ts
+var FeatureFlagManager, featureFlags;
+var init_feature_flags = __esm({
+  "src/services/ai-response/feature-flags.ts"() {
+    FeatureFlagManager = class _FeatureFlagManager {
+      static instance;
+      flags;
+      userHash = null;
+      constructor() {
+        this.flags = {
+          useRealProviders: false,
+          providerType: "template",
+          enableStreaming: false,
+          enableSafetyGuards: true,
+          enableTelemetry: true,
+          rolloutPercentage: 0
+        };
+        this.loadFromEnvironment();
+      }
+      static getInstance() {
+        if (!_FeatureFlagManager.instance) {
+          _FeatureFlagManager.instance = new _FeatureFlagManager();
+        }
+        return _FeatureFlagManager.instance;
+      }
+      /**
+       * Load flags from environment variables
+       */
+      loadFromEnvironment() {
+        const v3Enabled = process.env.AI_RESPONSE_V3 === "true";
+        if (v3Enabled) {
+          this.flags.useRealProviders = process.env.USE_REAL_AI_PROVIDERS === "true";
+          this.flags.providerType = process.env.AI_PROVIDER || "template";
+          this.flags.enableStreaming = process.env.ENABLE_STREAMING === "true";
+          this.flags.rolloutPercentage = parseInt(process.env.AI_ROLLOUT_PERCENTAGE || "0", 10);
+        }
+        this.flags.enableSafetyGuards = process.env.DISABLE_SAFETY_GUARDS !== "true";
+        this.flags.enableTelemetry = process.env.DISABLE_TELEMETRY !== "true";
+        console.log("[Feature Flags] Loaded configuration:", this.flags);
+      }
+      /**
+       * Check if a feature is enabled for the current user
+       */
+      isEnabled(feature) {
+        if (feature === "useRealProviders" && this.flags.rolloutPercentage < 100) {
+          return this.isInRolloutGroup();
+        }
+        return this.flags[feature];
+      }
+      /**
+       * Get a flag value
+       */
+      getFlag(key2) {
+        return this.flags[key2];
+      }
+      /**
+       * Set a flag value (for testing)
+       */
+      setFlag(key2, value2) {
+        this.flags[key2] = value2;
+        console.log(`[Feature Flags] Updated ${key2} to ${value2}`);
+      }
+      /**
+       * Set user identifier for consistent rollout
+       */
+      setUserIdentifier(userId) {
+        this.userHash = this.hashString(userId);
+      }
+      /**
+       * Check if current user is in rollout group
+       */
+      isInRolloutGroup() {
+        if (!this.userHash) {
+          return Math.random() * 100 < this.flags.rolloutPercentage;
+        }
+        const hashValue = parseInt(this.userHash.substring(0, 8), 16);
+        const userPercentage = hashValue % 100;
+        return userPercentage < this.flags.rolloutPercentage;
+      }
+      /**
+       * Simple hash function for consistent user assignment
+       */
+      hashString(str) {
+        let hash = 0;
+        for (let i2 = 0; i2 < str.length; i2++) {
+          const char = str.charCodeAt(i2);
+          hash = (hash << 5) - hash + char;
+          hash = hash & hash;
+        }
+        return Math.abs(hash).toString(16);
+      }
+      /**
+       * Get configuration for AI response service
+       */
+      getAIResponseConfig() {
+        return {
+          useRealProviders: this.isEnabled("useRealProviders"),
+          providerType: this.flags.providerType,
+          enableStreaming: this.isEnabled("enableStreaming"),
+          enableSafetyGuards: this.isEnabled("enableSafetyGuards"),
+          enableTelemetry: this.isEnabled("enableTelemetry")
+        };
+      }
+      /**
+       * Reset to defaults (for testing)
+       */
+      reset() {
+        this.flags = {
+          useRealProviders: false,
+          providerType: "template",
+          enableStreaming: false,
+          enableSafetyGuards: true,
+          enableTelemetry: true,
+          rolloutPercentage: 0
+        };
+        this.userHash = null;
+      }
+    };
+    featureFlags = FeatureFlagManager.getInstance();
+  }
+});
+
+// src/services/ai-response/telemetry/telemetry-collector.ts
+var TelemetryCollector;
+var init_telemetry_collector = __esm({
+  "src/services/ai-response/telemetry/telemetry-collector.ts"() {
+    TelemetryCollector = class _TelemetryCollector {
+      static instance;
+      events = [];
+      sessionId;
+      flushInterval = null;
+      aggregationInterval = null;
+      metricsBuffer = /* @__PURE__ */ new Map();
+      constructor() {
+        this.sessionId = this.generateSessionId();
+        this.startCollection();
+      }
+      static getInstance() {
+        if (!_TelemetryCollector.instance) {
+          _TelemetryCollector.instance = new _TelemetryCollector();
+        }
+        return _TelemetryCollector.instance;
+      }
+      /**
+       * Start collecting metrics
+       */
+      startCollection() {
+        this.flushInterval = setInterval(() => {
+          this.flushEvents();
+        }, 3e4);
+        this.aggregationInterval = setInterval(() => {
+          this.aggregateMetrics("minute");
+        }, 6e4);
+        console.log("[Telemetry] Collection started");
+      }
+      /**
+       * Track intent decision
+       */
+      trackIntent(metric) {
+        this.addEvent({
+          timestamp: Date.now(),
+          eventType: "intent_decided",
+          sessionId: this.sessionId,
+          data: metric
+        });
+      }
+      /**
+       * Track response generation
+       */
+      trackResponse(metric) {
+        this.addEvent({
+          timestamp: Date.now(),
+          eventType: "response_generated",
+          sessionId: this.sessionId,
+          data: metric
+        });
+        if (!metric.fallback) {
+          this.addEvent({
+            timestamp: Date.now(),
+            eventType: "provider_called",
+            sessionId: this.sessionId,
+            data: {
+              provider: metric.provider,
+              success: metric.success
+            }
+          });
+        }
+      }
+      /**
+       * Track safety violations
+       */
+      trackSafetyViolation(metric) {
+        this.addEvent({
+          timestamp: Date.now(),
+          eventType: "safety_violation",
+          sessionId: this.sessionId,
+          data: metric
+        });
+      }
+      /**
+       * Track user feedback
+       */
+      trackUserFeedback(metric) {
+        this.addEvent({
+          timestamp: Date.now(),
+          eventType: "user_feedback",
+          sessionId: this.sessionId,
+          data: metric
+        });
+      }
+      /**
+       * Track errors
+       */
+      trackError(error2, context2) {
+        this.addEvent({
+          timestamp: Date.now(),
+          eventType: "error_occurred",
+          sessionId: this.sessionId,
+          data: {
+            message: error2.message,
+            stack: error2.stack,
+            ...context2
+          }
+        });
+      }
+      /**
+       * Add event to buffer
+       */
+      addEvent(event) {
+        this.events.push(event);
+        if (this.events.length >= 100) {
+          this.flushEvents();
+        }
+      }
+      /**
+       * Flush events to storage/API
+       */
+      async flushEvents() {
+        if (this.events.length === 0) return;
+        const eventsToFlush = [...this.events];
+        this.events = [];
+        try {
+          if (process.env.TELEMETRY_ENDPOINT) {
+            await this.sendToEndpoint(eventsToFlush);
+          } else {
+            this.storeLocally(eventsToFlush);
+          }
+        } catch (error2) {
+          console.error("[Telemetry] Failed to flush events:", error2);
+          this.events.unshift(...eventsToFlush);
+        }
+      }
+      /**
+       * Send events to telemetry endpoint
+       */
+      async sendToEndpoint(events) {
+        const endpoint = process.env.TELEMETRY_ENDPOINT;
+        const apiKey2 = process.env.TELEMETRY_API_KEY;
+        if (!endpoint) return;
+        const response2 = await fetch(endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            ...apiKey2 && { "Authorization": `Bearer ${apiKey2}` }
+          },
+          body: JSON.stringify({ events })
+        });
+        if (!response2.ok) {
+          throw new Error(`Telemetry endpoint returned ${response2.status}`);
+        }
+      }
+      /**
+       * Store events locally (for development)
+       */
+      storeLocally(events) {
+        const key2 = `metrics_${Date.now()}`;
+        this.metricsBuffer.set(key2, this.calculateMetrics(events));
+        if (this.metricsBuffer.size > 100) {
+          const keys = Array.from(this.metricsBuffer.keys());
+          this.metricsBuffer.delete(keys[0]);
+        }
+      }
+      /**
+       * Calculate metrics from events
+       */
+      calculateMetrics(events) {
+        const now2 = Date.now();
+        const metrics2 = {
+          period: "minute",
+          startTime: now2 - 6e4,
+          endTime: now2,
+          // Intent metrics
+          intentCounts: {},
+          intentAccuracy: 0,
+          languageDistribution: {},
+          // Response metrics
+          totalResponses: 0,
+          averageLatency: 0,
+          p95Latency: 0,
+          p99Latency: 0,
+          providerDistribution: {},
+          fallbackRate: 0,
+          errorRate: 0,
+          // Token usage
+          totalTokens: 0,
+          averageTokensPerRequest: 0,
+          // Safety metrics
+          safetyViolations: 0,
+          violationTypes: {},
+          // User satisfaction
+          satisfactionRate: 0,
+          feedbackCount: 0,
+          feedbackDistribution: {}
+        };
+        const latencies = [];
+        let totalTokens = 0;
+        let feedbackPositive = 0;
+        let feedbackTotal = 0;
+        events.forEach((event) => {
+          switch (event.eventType) {
+            case "intent_decided":
+              const intent2 = event.data;
+              metrics2.intentCounts[intent2.type] = (metrics2.intentCounts[intent2.type] || 0) + 1;
+              metrics2.languageDistribution[intent2.language] = (metrics2.languageDistribution[intent2.language] || 0) + 1;
+              break;
+            case "response_generated":
+              const response2 = event.data;
+              metrics2.totalResponses++;
+              latencies.push(response2.latencyMs);
+              metrics2.providerDistribution[response2.provider] = (metrics2.providerDistribution[response2.provider] || 0) + 1;
+              if (response2.fallback) metrics2.fallbackRate++;
+              if (!response2.success) metrics2.errorRate++;
+              if (response2.tokenUsage) {
+                totalTokens += response2.tokenUsage.total;
+              }
+              break;
+            case "safety_violation":
+              const safety = event.data;
+              metrics2.safetyViolations++;
+              metrics2.violationTypes[safety.violationType] = (metrics2.violationTypes[safety.violationType] || 0) + 1;
+              break;
+            case "user_feedback":
+              const feedback = event.data;
+              feedbackTotal++;
+              if (feedback.rating === "positive") feedbackPositive++;
+              metrics2.feedbackDistribution[feedback.rating] = (metrics2.feedbackDistribution[feedback.rating] || 0) + 1;
+              break;
+          }
+        });
+        if (latencies.length > 0) {
+          latencies.sort((a2, b) => a2 - b);
+          metrics2.averageLatency = latencies.reduce((a2, b) => a2 + b, 0) / latencies.length;
+          metrics2.p95Latency = latencies[Math.floor(latencies.length * 0.95)] || 0;
+          metrics2.p99Latency = latencies[Math.floor(latencies.length * 0.99)] || 0;
+        }
+        if (metrics2.totalResponses > 0) {
+          metrics2.fallbackRate = metrics2.fallbackRate / metrics2.totalResponses;
+          metrics2.errorRate = metrics2.errorRate / metrics2.totalResponses;
+          metrics2.averageTokensPerRequest = totalTokens / metrics2.totalResponses;
+        }
+        if (feedbackTotal > 0) {
+          metrics2.satisfactionRate = feedbackPositive / feedbackTotal;
+        }
+        metrics2.feedbackCount = feedbackTotal;
+        metrics2.totalTokens = totalTokens;
+        return metrics2;
+      }
+      /**
+       * Aggregate metrics by period
+       */
+      aggregateMetrics(period) {
+        const recentEvents = this.getRecentEvents(period);
+        const metrics2 = this.calculateMetrics(recentEvents);
+        const key2 = `${period}_${Date.now()}`;
+        this.metricsBuffer.set(key2, metrics2);
+        console.log(`[Telemetry] Aggregated ${period} metrics:`, {
+          responses: metrics2.totalResponses,
+          avgLatency: Math.round(metrics2.averageLatency),
+          satisfaction: Math.round(metrics2.satisfactionRate * 100) + "%"
+        });
+      }
+      /**
+       * Get recent events by period
+       */
+      getRecentEvents(period) {
+        const now2 = Date.now();
+        const duration = period === "minute" ? 6e4 : period === "hour" ? 36e5 : 864e5;
+        return this.events.filter((e2) => e2.timestamp > now2 - duration);
+      }
+      /**
+       * Get current metrics
+       */
+      getCurrentMetrics() {
+        const keys = Array.from(this.metricsBuffer.keys()).filter((k) => k.startsWith("minute_")).sort();
+        if (keys.length === 0) return null;
+        return this.metricsBuffer.get(keys[keys.length - 1]) || null;
+      }
+      /**
+       * Get historical metrics
+       */
+      getHistoricalMetrics(period, count = 10) {
+        const prefix = `${period}_`;
+        const keys = Array.from(this.metricsBuffer.keys()).filter((k) => k.startsWith(prefix)).sort().slice(-count);
+        return keys.map((k) => this.metricsBuffer.get(k)).filter(Boolean);
+      }
+      /**
+       * Generate session ID
+       */
+      generateSessionId() {
+        return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+      }
+      /**
+       * Stop collection
+       */
+      stop() {
+        if (this.flushInterval) {
+          clearInterval(this.flushInterval);
+          this.flushInterval = null;
+        }
+        if (this.aggregationInterval) {
+          clearInterval(this.aggregationInterval);
+          this.aggregationInterval = null;
+        }
+        this.flushEvents();
+        console.log("[Telemetry] Collection stopped");
+      }
+    };
+  }
+});
+
+// src/services/ai-response/context.ts
+function buildContextForAI(sessionMemory2, options2 = {}) {
+  const {
+    budgetChars = 8e3,
+    maxMessages = 20,
+    summaryThreshold = 6
+  } = options2;
+  const reversed = [...sessionMemory2].reverse();
+  const recentMessages2 = [];
+  let totalChars = 0;
+  let messageCount = 0;
+  for (const msg2 of reversed) {
+    const content2 = msg2.content || "";
+    const msgLength = content2.length;
+    if (totalChars + msgLength > budgetChars || messageCount >= maxMessages) {
+      break;
+    }
+    recentMessages2.push({
+      role: msg2.role,
+      content: content2,
+      timestamp: msg2.timestamp
+    });
+    totalChars += msgLength;
+    messageCount++;
+  }
+  recentMessages2.reverse();
+  let rollingSummary;
+  if (sessionMemory2.length > summaryThreshold && recentMessages2.length < sessionMemory2.length) {
+    const olderMessages = sessionMemory2.slice(0, sessionMemory2.length - recentMessages2.length);
+    rollingSummary = createRollingSummary(olderMessages, 1200);
+  }
+  return {
+    recentMessages: recentMessages2,
+    rollingSummary,
+    totalChars,
+    messageCount
+  };
+}
+function createRollingSummary(messages2, maxChars) {
+  const summaryParts = [];
+  let currentLength = 0;
+  for (const msg2 of messages2) {
+    const role2 = msg2.role === "user" ? "U" : "A";
+    const preview = msg2.content.substring(0, 100).replace(/\n/g, " ");
+    const summary = `${role2}: ${preview}${msg2.content.length > 100 ? "..." : ""}`;
+    if (currentLength + summary.length > maxChars) {
+      break;
+    }
+    summaryParts.push(summary);
+    currentLength += summary.length + 1;
+  }
+  return summaryParts.join("\n");
+}
+function extractKeyTopics(context2) {
+  const topics = /* @__PURE__ */ new Set();
+  const allText = context2.recentMessages.map((m2) => m2.content).join(" ").toLowerCase();
+  const languages2 = ["typescript", "javascript", "python", "java", "go", "rust", "react", "vue", "angular"];
+  languages2.forEach((lang) => {
+    if (allText.includes(lang)) topics.add(lang);
+  });
+  const tools = ["next.js", "nextjs", "express", "fastapi", "django", "spring", "docker", "kubernetes"];
+  tools.forEach((tool2) => {
+    if (allText.includes(tool2)) topics.add(tool2);
+  });
+  const concepts = ["api", "database", "authentication", "testing", "deployment", "frontend", "backend"];
+  concepts.forEach((concept) => {
+    if (allText.includes(concept)) topics.add(concept);
+  });
+  return Array.from(topics);
+}
+function getContextStats(context2) {
+  return {
+    messageCount: context2.messageCount,
+    totalChars: context2.totalChars,
+    hasSummary: !!context2.rollingSummary,
+    avgMessageLength: context2.totalChars / (context2.messageCount || 1),
+    topics: extractKeyTopics(context2)
+  };
+}
+var init_context = __esm({
+  "src/services/ai-response/context.ts"() {
+  }
+});
+
+// src/services/ai-response/responders/common.ts
+function generateFooter(isJapanese, customOptions) {
+  if (customOptions && customOptions.length > 0) {
+    const numbered = customOptions.map((opt, i2) => `${i2 + 1}) ${opt}`).join("  ");
+    return isJapanese ? `
+---
+\u6B21\u306E\u30B9\u30C6\u30C3\u30D7: ${numbered}
+\u756A\u53F7\u3067\u6307\u793A\u3057\u3066\u304F\u3060\u3055\u3044\u3002` : `
+---
+Next steps: ${numbered}
+Reply with a number.`;
+  }
+  return isJapanese ? "\n---\n\u6B21\u306B\u9032\u3081\u308B\u9805\u76EE: 1) \u6700\u5C0F\u3067\u52D5\u304B\u3059  2) \u8A2D\u8A08\u3092\u56FA\u3081\u308B  3) \u65E2\u5B58\u30B3\u30FC\u30C9\u306B\u9069\u7528\n\u756A\u53F7\u3067\u6307\u793A\u3057\u3066\u304F\u3060\u3055\u3044\u3002" : "\n---\nNext: 1) Run minimal  2) Lock design  3) Apply to existing\nReply with a number.";
+}
+function formatFileBlock(path21, lang, content2) {
+  return `**${path21}**
+\`\`\`${lang}
+${content2}
+\`\`\``;
+}
+function createSectionHeader(title2, level2 = 2) {
+  const prefix = "#".repeat(level2);
+  return `${prefix} ${title2}`;
+}
+function formatList(items, ordered = false) {
+  return items.map(
+    (item2, i2) => ordered ? `${i2 + 1}. ${item2}` : `\u2022 ${item2}`
+  ).join("\n");
+}
+function truncateText(text2, maxLength) {
+  if (text2.length <= maxLength) return text2;
+  return text2.substring(0, maxLength - 3) + "...";
+}
+function cleanUserInput(input3) {
+  return input3.trim().replace(/\s+/g, " ").substring(0, 100);
+}
+var init_common = __esm({
+  "src/services/ai-response/responders/common.ts"() {
+  }
+});
+
+// src/services/ai-response/responders/code.ts
+function buildCodeResponse(options2) {
+  const {
+    title: title2,
+    files: files2,
+    runCommands,
+    notes = [],
+    dependencies: dependencies2 = [],
+    envVars = {},
+    isJapanese = false
+  } = options2;
+  const parts2 = [];
+  parts2.push(`### ${title2}`);
+  parts2.push("");
+  files2.forEach((file2) => {
+    parts2.push(formatFileBlock(file2.path, file2.lang, file2.content));
+    parts2.push("");
+  });
+  if (dependencies2.length > 0) {
+    parts2.push(isJapanese ? "**\u5FC5\u8981\u306A\u4F9D\u5B58\u95A2\u4FC2**" : "**Dependencies**");
+    parts2.push("```bash");
+    parts2.push(
+      isJapanese ? `pnpm add ${dependencies2.join(" ")}` : `npm install ${dependencies2.join(" ")}`
+    );
+    parts2.push("```");
+    parts2.push("");
+  }
+  if (Object.keys(envVars).length > 0) {
+    parts2.push(isJapanese ? "**\u74B0\u5883\u5909\u6570 (.env)**" : "**Environment Variables (.env)**");
+    parts2.push("```env");
+    Object.entries(envVars).forEach(([key2, value2]) => {
+      parts2.push(`${key2}=${value2}`);
+    });
+    parts2.push("```");
+    parts2.push("");
+  }
+  parts2.push(isJapanese ? "**\u5B9F\u884C\u624B\u9806**" : "**Run Instructions**");
+  parts2.push(formatList(runCommands, true));
+  parts2.push("");
+  const defaultNotes = isJapanese ? ["\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u305F\u5834\u5408\u306F\u3001\u4F9D\u5B58\u95A2\u4FC2\u304C\u6B63\u3057\u304F\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u3055\u308C\u3066\u3044\u308B\u304B\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044"] : ["If you encounter errors, ensure all dependencies are properly installed"];
+  const allNotes = [...notes, ...defaultNotes];
+  parts2.push(isJapanese ? "**\u6CE8\u610F\u4E8B\u9805**" : "**Notes**");
+  parts2.push(formatList(allNotes));
+  const footerOptions = isJapanese ? ["\u30A8\u30E9\u30FC\u51E6\u7406\u3092\u8FFD\u52A0", "\u30C6\u30B9\u30C8\u3092\u66F8\u304F", "\u6A5F\u80FD\u3092\u62E1\u5F35"] : ["Add error handling", "Write tests", "Extend features"];
+  parts2.push(generateFooter(isJapanese, footerOptions));
+  return parts2.join("\n");
+}
+function generateCLITemplate(isJapanese) {
+  return buildCodeResponse({
+    title: isJapanese ? "TypeScript CLI \u30A2\u30D7\u30EA\u30B1\u30FC\u30B7\u30E7\u30F3" : "TypeScript CLI Application",
+    files: [
+      {
+        path: "src/index.ts",
+        lang: "typescript",
+        content: `#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+
+const program = new Command();
+
+program
+  .name('my-cli')
+  .description('CLI application template')
+  .version('1.0.0');
+
+program
+  .command('greet <name>')
+  .description('Greet someone')
+  .option('-u, --uppercase', 'Convert to uppercase')
+  .action((name: string, options: { uppercase?: boolean }) => {
+    const greeting = options.uppercase 
+      ? \`HELLO \${name.toUpperCase()}!\`
+      : \`Hello \${name}!\`;
+    console.log(chalk.green(greeting));
+  });
+
+program.parse(process.argv);`
+      },
+      {
+        path: "package.json",
+        lang: "json",
+        content: `{
+  "name": "my-cli",
+  "version": "1.0.0",
+  "type": "module",
+  "bin": {
+    "my-cli": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "tsx": "^4.6.0",
+    "typescript": "^5.3.0"
+  }
+}`
+      },
+      {
+        path: "tsconfig.json",
+        lang: "json",
+        content: `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}`
+      }
+    ],
+    runCommands: isJapanese ? [
+      "pnpm install",
+      "pnpm build",
+      "node dist/index.js greet World",
+      "npm link (\u30B0\u30ED\u30FC\u30D0\u30EB\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u7528)"
+    ] : [
+      "npm install",
+      "npm run build",
+      "node dist/index.js greet World",
+      "npm link (for global installation)"
+    ],
+    dependencies: ["chalk", "commander"],
+    notes: isJapanese ? ["tsx \u3092\u4F7F\u7528\u3057\u3066\u958B\u767A\u4E2D\u306F TypeScript \u3092\u76F4\u63A5\u5B9F\u884C\u3067\u304D\u307E\u3059"] : ["Use tsx to run TypeScript directly during development"],
+    isJapanese
+  });
+}
+function generateNextAPITemplate(isJapanese) {
+  return buildCodeResponse({
+    title: isJapanese ? "Next.js API \u30EB\u30FC\u30C8" : "Next.js API Route",
+    files: [
+      {
+        path: "app/api/users/route.ts",
+        lang: "typescript",
+        content: `import { NextRequest, NextResponse } from 'next/server';
+
+// Sample data
+const users = [
+  { id: 1, name: 'Alice', email: 'alice@example.com' },
+  { id: 2, name: 'Bob', email: 'bob@example.com' }
+];
+
+export async function GET(request: NextRequest) {
+  try {
+    const searchParams = request.nextUrl.searchParams;
+    const id = searchParams.get('id');
+    
+    if (id) {
+      const user = users.find(u => u.id === parseInt(id));
+      if (!user) {
+        return NextResponse.json(
+          { error: 'User not found' },
+          { status: 404 }
+        );
+      }
+      return NextResponse.json(user);
+    }
+    
+    return NextResponse.json(users);
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { name, email } = body;
+    
+    if (!name || !email) {
+      return NextResponse.json(
+        { error: 'Name and email are required' },
+        { status: 400 }
+      );
+    }
+    
+    const newUser = {
+      id: users.length + 1,
+      name,
+      email
+    };
+    
+    users.push(newUser);
+    
+    return NextResponse.json(newUser, { status: 201 });
+  } catch (error) {
+    return NextResponse.json(
+      { error: 'Invalid request body' },
+      { status: 400 }
+    );
+  }
+}`
+      },
+      {
+        path: "app/api/users/[id]/route.ts",
+        lang: "typescript",
+        content: `import { NextRequest, NextResponse } from 'next/server';
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: { id: string } }
+) {
+  return NextResponse.json({ 
+    message: \`User \${params.id} details\` 
+  });
+}
+
+export async function PUT(
+  request: NextRequest,
+  { params }: { params: { id: string } }
+) {
+  const body = await request.json();
+  return NextResponse.json({ 
+    message: \`Updated user \${params.id}\`,
+    data: body
+  });
+}
+
+export async function DELETE(
+  request: NextRequest,
+  { params }: { params: { id: string } }
+) {
+  return NextResponse.json({ 
+    message: \`Deleted user \${params.id}\` 
+  });
+}`
+      }
+    ],
+    runCommands: isJapanese ? [
+      "Next.js \u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u306B\u914D\u7F6E",
+      "pnpm dev \u3067\u30B5\u30FC\u30D0\u30FC\u8D77\u52D5",
+      "curl http://localhost:3000/api/users \u3067\u30C6\u30B9\u30C8"
+    ] : [
+      "Place in Next.js project",
+      "Run server with npm run dev",
+      "Test with curl http://localhost:3000/api/users"
+    ],
+    notes: isJapanese ? [
+      "App Router (Next.js 13+) \u3092\u4F7F\u7528",
+      "\u30C7\u30FC\u30BF\u30D9\u30FC\u30B9\u63A5\u7D9A\u306F\u5225\u9014\u5B9F\u88C5\u304C\u5FC5\u8981",
+      "Middleware \u3067\u8A8D\u8A3C\u3092\u8FFD\u52A0\u53EF\u80FD"
+    ] : [
+      "Uses App Router (Next.js 13+)",
+      "Database connection needs separate implementation",
+      "Can add authentication via middleware"
+    ],
+    envVars: {
+      "DATABASE_URL": "postgresql://user:pass@localhost/db"
+    },
+    isJapanese
+  });
+}
+var init_code = __esm({
+  "src/services/ai-response/responders/code.ts"() {
+    init_common();
+  }
+});
+
+// src/services/ai-response/responders/continuation.ts
+function buildContinuationPrompt(contextPreview, isJapanese, customOptions) {
+  const parts2 = [];
+  parts2.push(isJapanese ? "\u7D9A\u304D\u3067\u3059\u306D\u3002\u76F4\u8FD1\u306E\u6D41\u308C\u3092\u78BA\u8A8D\u3057\u307E\u3057\u305F\u3002" : "I see you want to continue. Here's the recent context.");
+  parts2.push("");
+  if (contextPreview) {
+    parts2.push(isJapanese ? "**\u76F4\u8FD1\u306E\u5185\u5BB9:**" : "**Recent context:**");
+    parts2.push(`> ${truncateText(contextPreview, 300)}`);
+    parts2.push("");
+  }
+  const defaultOptions = isJapanese ? [
+    "\u30A8\u30E9\u30FC\u51E6\u7406\u306E\u8FFD\u52A0\uFF08try/catch\u30FB\u5177\u4F53\u7684\u30E1\u30C3\u30BB\u30FC\u30B8\uFF09",
+    "\u30E2\u30B8\u30E5\u30FC\u30EB\u5206\u5272\uFF08\u95A2\u5FC3\u306E\u5206\u96E2\uFF09",
+    "\u30C6\u30B9\u30C8\u8FFD\u52A0\uFF08\u5358\u4F53\u30C6\u30B9\u30C8\u30FB\u7D71\u5408\u30C6\u30B9\u30C8\uFF09",
+    "\u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9\u6539\u5584\uFF08\u6700\u9069\u5316\u30FB\u30AD\u30E3\u30C3\u30B7\u30E5\uFF09",
+    "\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8\u4F5C\u6210\uFF08README\u30FBAPI\u4ED5\u69D8\uFF09"
+  ] : [
+    "Add error handling (try/catch with specific messages)",
+    "Split into modules (separation of concerns)",
+    "Add tests (unit and integration)",
+    "Improve performance (optimization & caching)",
+    "Create documentation (README & API specs)"
+  ];
+  const options2 = customOptions && customOptions.length > 0 ? customOptions : defaultOptions;
+  parts2.push(
+    isJapanese ? "**\u6B21\u306E\u30B9\u30C6\u30C3\u30D7\u3092\u9078\u3093\u3067\u304F\u3060\u3055\u3044:**" : "**Choose your next step:**"
+  );
+  parts2.push("");
+  options2.forEach((option, i2) => {
+    parts2.push(`${i2 + 1}) ${option}`);
+  });
+  parts2.push("");
+  parts2.push(
+    isJapanese ? "\u{1F4A1} \u63A8\u5968: \u8FF7\u3046\u5834\u5408\u306F 2\u21921\u21923 \u306E\u9806\u304C\u304A\u3059\u3059\u3081\u3067\u3059\u3002" : "\u{1F4A1} Tip: If unsure, try 2\u21921\u21923 in that order."
+  );
+  parts2.push(
+    isJapanese ? "\n\u756A\u53F7\u3067\u6307\u793A\u3057\u3066\u304F\u3060\u3055\u3044\uFF081-5\uFF09\u3002\u8A73\u7D30\u306A\u8AAC\u660E\u3092\u8FFD\u52A0\u3057\u3066\u3082\u69CB\u3044\u307E\u305B\u3093\u3002" : "\nReply with a number (1-5). You can add details to your choice."
+  );
+  return parts2.join("\n");
+}
+function generateTopicBasedContinuation(topics, isJapanese) {
+  const options2 = [];
+  if (topics.some((t) => ["react", "vue", "angular", "frontend"].includes(t))) {
+    options2.push(
+      isJapanese ? "\u30B3\u30F3\u30DD\u30FC\u30CD\u30F3\u30C8\u306E\u5206\u5272\u3068props\u8A2D\u8A08" : "Component splitting and props design"
+    );
+    options2.push(
+      isJapanese ? "\u72B6\u614B\u7BA1\u7406\u306E\u5B9F\u88C5\uFF08Context/Redux/Zustand\uFF09" : "State management (Context/Redux/Zustand)"
+    );
+  }
+  if (topics.some((t) => ["api", "backend", "express", "fastapi"].includes(t))) {
+    options2.push(
+      isJapanese ? "API\u30A8\u30F3\u30C9\u30DD\u30A4\u30F3\u30C8\u306E\u8FFD\u52A0" : "Add API endpoints"
+    );
+    options2.push(
+      isJapanese ? "\u8A8D\u8A3C\u30FB\u8A8D\u53EF\u306E\u5B9F\u88C5" : "Implement authentication & authorization"
+    );
+  }
+  if (topics.some((t) => ["database", "sql", "mongodb", "postgres"].includes(t))) {
+    options2.push(
+      isJapanese ? "\u30C7\u30FC\u30BF\u30D9\u30FC\u30B9\u30B9\u30AD\u30FC\u30DE\u306E\u8A2D\u8A08" : "Design database schema"
+    );
+    options2.push(
+      isJapanese ? "\u30DE\u30A4\u30B0\u30EC\u30FC\u30B7\u30E7\u30F3\u3068\u30B7\u30FC\u30C9\u4F5C\u6210" : "Create migrations and seeds"
+    );
+  }
+  if (topics.some((t) => ["test", "testing", "jest", "vitest"].includes(t))) {
+    options2.push(
+      isJapanese ? "\u30E6\u30CB\u30C3\u30C8\u30C6\u30B9\u30C8\u306E\u8FFD\u52A0" : "Add unit tests"
+    );
+    options2.push(
+      isJapanese ? "E2E\u30C6\u30B9\u30C8\u306E\u5B9F\u88C5" : "Implement E2E tests"
+    );
+  }
+  if (options2.length === 0) {
+    options2.push(
+      isJapanese ? "\u30B3\u30FC\u30C9\u306E\u8A73\u7D30\u306A\u5B9F\u88C5" : "Detailed code implementation"
+    );
+    options2.push(
+      isJapanese ? "\u8A2D\u8A08\u30D1\u30BF\u30FC\u30F3\u306E\u9069\u7528" : "Apply design patterns"
+    );
+  }
+  return options2;
+}
+function buildSmartContinuation(context2, detectedTopics, isJapanese) {
+  const topicOptions = generateTopicBasedContinuation(detectedTopics, isJapanese);
+  const generalOptions = isJapanese ? ["\u65E2\u5B58\u30B3\u30FC\u30C9\u306E\u30EA\u30D5\u30A1\u30AF\u30BF\u30EA\u30F3\u30B0", "\u65B0\u6A5F\u80FD\u306E\u8FFD\u52A0"] : ["Refactor existing code", "Add new features"];
+  const allOptions = [...topicOptions, ...generalOptions].slice(0, 5);
+  return buildContinuationPrompt(context2, isJapanese, allOptions);
+}
+var init_continuation = __esm({
+  "src/services/ai-response/responders/continuation.ts"() {
+    init_common();
+  }
+});
+
+// src/services/ai-response/responders/question.ts
+function buildQuestionResponse(options2) {
+  const { question, isJapanese, topics = [], includeExample = true } = options2;
+  const parts2 = [];
+  const cleanQuestion = cleanUserInput(question);
+  parts2.push(
+    isJapanese ? `\u3054\u8CEA\u554F\u3042\u308A\u304C\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002\u300C${cleanQuestion}\u300D\u306B\u3064\u3044\u3066\u8AAC\u660E\u3057\u307E\u3059\u3002` : `Great question about "${cleanQuestion}". Let me explain.`
+  );
+  parts2.push("");
+  parts2.push(createSectionHeader(
+    isJapanese ? "\u56DE\u7B54\u306E\u69CB\u6210" : "Answer Structure",
+    3
+  ));
+  parts2.push("");
+  const structure2 = isJapanese ? [
+    "\u80CC\u666F\u3068\u57FA\u672C\u6982\u5FF5",
+    "\u5B9F\u88C5\u65B9\u6CD5\uFF08\u6700\u5C0F\u4F8B\uFF09",
+    "\u30D9\u30B9\u30C8\u30D7\u30E9\u30AF\u30C6\u30A3\u30B9\u3068\u6CE8\u610F\u70B9",
+    "\u5B9F\u969B\u306E\u4F7F\u7528\u4F8B"
+  ] : [
+    "Background & Concepts",
+    "Implementation (minimal example)",
+    "Best practices & pitfalls",
+    "Real-world use cases"
+  ];
+  parts2.push(formatList(structure2, true));
+  parts2.push("");
+  parts2.push(createSectionHeader(
+    isJapanese ? "\u7C21\u6F54\u306A\u56DE\u7B54" : "Quick Answer",
+    3
+  ));
+  parts2.push("");
+  parts2.push(generateQuickAnswer(question, isJapanese, topics));
+  parts2.push("");
+  if (includeExample && shouldIncludeCode(question)) {
+    parts2.push(createSectionHeader(
+      isJapanese ? "\u30B3\u30FC\u30C9\u4F8B" : "Code Example",
+      3
+    ));
+    parts2.push("");
+    parts2.push(generateExampleCode(topics));
+    parts2.push("");
+  }
+  parts2.push(createSectionHeader(
+    isJapanese ? "\u8A73\u7D30\u3092\u77E5\u308A\u305F\u3044\u5834\u5408" : "Want to know more?",
+    3
+  ));
+  parts2.push("");
+  const detailOptions = isJapanese ? [
+    "\u8A73\u7D30\u306A\u5B9F\u88C5\u4F8B\u3092\u898B\u308B",
+    "\u95A2\u9023\u3059\u308B\u6982\u5FF5\u3092\u5B66\u3076",
+    "\u30C8\u30E9\u30D6\u30EB\u30B7\u30E5\u30FC\u30C6\u30A3\u30F3\u30B0",
+    "\u5B9F\u969B\u306E\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u3078\u306E\u9069\u7528"
+  ] : [
+    "See detailed implementation",
+    "Learn related concepts",
+    "Troubleshooting guide",
+    "Apply to real project"
+  ];
+  parts2.push(formatList(detailOptions, true));
+  parts2.push("");
+  parts2.push(
+    isJapanese ? "\u756A\u53F7\u3092\u9078\u3093\u3067\u8A73\u7D30\u3092\u78BA\u8A8D\u3059\u308B\u304B\u3001\u8FFD\u52A0\u306E\u8CEA\u554F\u3092\u3057\u3066\u304F\u3060\u3055\u3044\u3002" : "Choose a number for details or ask a follow-up question."
+  );
+  return parts2.join("\n");
+}
+function generateQuickAnswer(question, isJapanese, topics) {
+  const lowerQuestion = question.toLowerCase();
+  if (lowerQuestion.includes("difference") || lowerQuestion.includes("\u9055\u3044")) {
+    return isJapanese ? "\u4E3B\u306A\u9055\u3044\u306F\u3001\u76EE\u7684\u3068\u4F7F\u7528\u5834\u9762\u306B\u3042\u308A\u307E\u3059\u3002\u305D\u308C\u305E\u308C\u306E\u7279\u5FB4\u3092\u6BD4\u8F03\u3059\u308B\u3068..." : "The main difference lies in their purpose and use cases. Comparing their features...";
+  }
+  if (lowerQuestion.includes("how to") || lowerQuestion.includes("\u65B9\u6CD5")) {
+    return isJapanese ? "\u5B9F\u88C5\u3059\u308B\u306B\u306F\u3001\u4EE5\u4E0B\u306E\u624B\u9806\u306B\u5F93\u3044\u307E\u3059\uFF1A1) \u6E96\u5099\u30012) \u5B9F\u88C5\u30013) \u30C6\u30B9\u30C8" : "To implement this, follow these steps: 1) Setup, 2) Implementation, 3) Testing";
+  }
+  if (lowerQuestion.includes("why") || lowerQuestion.includes("\u306A\u305C")) {
+    return isJapanese ? "\u3053\u308C\u306B\u306F\u6280\u8853\u7684\u306A\u7406\u7531\u3068\u5B9F\u7528\u7684\u306A\u7406\u7531\u304C\u3042\u308A\u307E\u3059\u3002\u4E3B\u306A\u7406\u7531\u306F..." : "There are both technical and practical reasons. The main reasons are...";
+  }
+  if (lowerQuestion.includes("when") || lowerQuestion.includes("\u3044\u3064")) {
+    return isJapanese ? "\u4F7F\u7528\u3059\u308B\u30BF\u30A4\u30DF\u30F3\u30B0\u306F\u3001\u7279\u5B9A\u306E\u6761\u4EF6\u304C\u63C3\u3063\u305F\u6642\u3067\u3059\u3002\u5177\u4F53\u7684\u306B\u306F..." : "Use this when specific conditions are met. Specifically...";
+  }
+  return isJapanese ? `${topics.length > 0 ? topics[0] + "\u306B\u95A2\u3057\u3066\u3001" : ""}\u91CD\u8981\u306A\u30DD\u30A4\u30F3\u30C8\u3092\u307E\u3068\u3081\u308B\u3068...` : `${topics.length > 0 ? "Regarding " + topics[0] + ", " : ""}The key points are...`;
+}
+function shouldIncludeCode(question) {
+  const codeIndicators = [
+    "implement",
+    "code",
+    "example",
+    "how to",
+    "\u5B9F\u88C5",
+    "\u30B3\u30FC\u30C9",
+    "\u4F8B",
+    "\u65B9\u6CD5",
+    "\u30B5\u30F3\u30D7\u30EB"
+  ];
+  const lower = question.toLowerCase();
+  return codeIndicators.some((indicator) => lower.includes(indicator));
+}
+function generateExampleCode(topics) {
+  if (topics.includes("react")) {
+    return `\`\`\`tsx
+const MyComponent = ({ title }: { title: string }) => {
+  const [count, setCount] = useState(0);
+  
+  return (
+    <div>
+      <h1>{title}</h1>
+      <button onClick={() => setCount(c => c + 1)}>
+        Count: {count}
+      </button>
+    </div>
+  );
+};
+\`\`\``;
+  }
+  if (topics.includes("api")) {
+    return `\`\`\`typescript
+app.get('/api/users/:id', async (req, res) => {
+  try {
+    const user = await getUserById(req.params.id);
+    res.json(user);
+  } catch (error) {
+    res.status(404).json({ error: 'User not found' });
+  }
+});
+\`\`\``;
+  }
+  return `\`\`\`typescript
+// Example implementation
+function solution(input: string): string {
+  // Process input
+  const processed = input.trim().toLowerCase();
+  
+  // Apply logic
+  const result = processData(processed);
+  
+  // Return result
+  return result;
+}
+\`\`\``;
+}
+function buildComprehensiveAnswer(question, detectedTopics, isJapanese) {
+  return buildQuestionResponse({
+    question,
+    isJapanese,
+    topics: detectedTopics,
+    includeExample: true
+  });
+}
+var init_question = __esm({
+  "src/services/ai-response/responders/question.ts"() {
+    init_common();
+  }
+});
+
+// src/services/ai-response/guards/safety.ts
+function checkInputSafety(input3, config2 = {}) {
+  const {
+    enablePIICheck = true,
+    enablePromptInjectionCheck = true
+  } = config2;
+  if (enablePIICheck && containsPII(input3)) {
+    return {
+      safe: false,
+      reason: "Input contains potential personal information",
+      suggestion: "Please remove sensitive information before proceeding"
+    };
+  }
+  if (enablePromptInjectionCheck && containsInjection(input3)) {
+    return {
+      safe: false,
+      reason: "Input contains potential prompt injection",
+      suggestion: "Please rephrase your request without system instructions"
+    };
+  }
+  const harmful = detectHarmfulContent(input3);
+  if (harmful.length > 0) {
+    return {
+      safe: true,
+      // Allow but warn
+      reason: `Note: Input mentions sensitive topics: ${harmful.join(", ")}`,
+      suggestion: "Ensure you're not exposing sensitive data"
+    };
+  }
+  return { safe: true };
+}
+function checkOutputSafety(output2, config2 = {}) {
+  const {
+    maxOutputChars = 5e4,
+    // ~50KB
+    maxCodeBlocks = 10
+  } = config2;
+  if (output2.length > maxOutputChars) {
+    return {
+      safe: false,
+      reason: `Output too large (${output2.length} chars > ${maxOutputChars})`,
+      suggestion: "Output has been truncated for safety"
+    };
+  }
+  const codeBlockCount = (output2.match(/```/g) || []).length / 2;
+  if (codeBlockCount > maxCodeBlocks) {
+    return {
+      safe: false,
+      reason: `Too many code blocks (${codeBlockCount} > ${maxCodeBlocks})`,
+      suggestion: "Consider splitting into multiple responses"
+    };
+  }
+  return { safe: true };
+}
+function containsPII(input3) {
+  return PII_PATTERNS.some((pattern2) => pattern2.test(input3));
+}
+function containsInjection(input3) {
+  return INJECTION_PATTERNS.some((pattern2) => pattern2.test(input3));
+}
+function detectHarmfulContent(input3) {
+  const lower = input3.toLowerCase();
+  return HARMFUL_KEYWORDS.filter((keyword) => lower.includes(keyword.toLowerCase()));
+}
+function sanitizeOutput(output2, maxChars = 5e4) {
+  if (output2.length > maxChars) {
+    return output2.substring(0, maxChars) + "\n\n... [Output truncated for safety]";
+  }
+  let sanitized = output2;
+  PII_PATTERNS.forEach((pattern2) => {
+    sanitized = sanitized.replace(pattern2, "[REDACTED]");
+  });
+  return sanitized;
+}
+function isExplicitContentAllowed(input3, explicitKeyword) {
+  const lower = input3.toLowerCase();
+  return lower.includes(explicitKeyword.toLowerCase());
+}
+function generateRejectionMessage(reason, isJapanese) {
+  const baseMessage = isJapanese ? `\u7533\u3057\u8A33\u3054\u3056\u3044\u307E\u305B\u3093\u3002\u5B89\u5168\u4E0A\u306E\u7406\u7531\u306B\u3088\u308A\u3001\u3053\u306E\u30EA\u30AF\u30A8\u30B9\u30C8\u306F\u51E6\u7406\u3067\u304D\u307E\u305B\u3093\u3002` : `I apologize, but I cannot process this request for safety reasons.`;
+  const suggestions2 = isJapanese ? [
+    "\u500B\u4EBA\u60C5\u5831\u3092\u9664\u5916\u3057\u3066\u304F\u3060\u3055\u3044",
+    "\u30EA\u30AF\u30A8\u30B9\u30C8\u3092\u8A00\u3044\u63DB\u3048\u3066\u304F\u3060\u3055\u3044",
+    "\u5C0F\u3055\u306A\u90E8\u5206\u306B\u5206\u5272\u3057\u3066\u304F\u3060\u3055\u3044"
+  ] : [
+    "Remove personal information",
+    "Rephrase your request",
+    "Break into smaller parts"
+  ];
+  return `${baseMessage}
+
+**${isJapanese ? "\u7406\u7531" : "Reason"}:** ${reason}
+
+**${isJapanese ? "\u63D0\u6848" : "Suggestions"}:**
+${suggestions2.map((s2, i2) => `${i2 + 1}. ${s2}`).join("\n")}`;
+}
+function logSafetyEvent(event) {
+  console.log("[Safety Guard]", {
+    ...event,
+    timestamp: event.timestamp || Date.now()
+  });
+}
+var PII_PATTERNS, HARMFUL_KEYWORDS, INJECTION_PATTERNS;
+var init_safety = __esm({
+  "src/services/ai-response/guards/safety.ts"() {
+    PII_PATTERNS = [
+      /\b\d{3}-\d{2}-\d{4}\b/,
+      // SSN
+      /\b\d{16}\b/,
+      // Credit card
+      /\b[A-Z]{2}\d{6}\b/,
+      // Passport
+      /\b\d{3}-?\d{3}-?\d{4}\b/
+      // Phone
+    ];
+    HARMFUL_KEYWORDS = [
+      "password",
+      "secret",
+      "token",
+      "api_key",
+      "private_key",
+      "\u30D1\u30B9\u30EF\u30FC\u30C9",
+      "\u30B7\u30FC\u30AF\u30EC\u30C3\u30C8",
+      "\u30C8\u30FC\u30AF\u30F3",
+      "\u79D8\u5BC6\u9375"
+    ];
+    INJECTION_PATTERNS = [
+      /ignore.*previous.*instructions?/i,
+      /disregard.*above/i,
+      /forget.*everything/i,
+      /system.*prompt/i,
+      /you.*are.*now/i,
+      /前の.*指示.*無視/,
+      /システム.*プロンプト/
+    ];
+  }
+});
+
 // src/services/ai-response.service.ts
 var AIResponseService;
 var init_ai_response_service = __esm({
@@ -11764,216 +14280,345 @@ var init_ai_response_service = __esm({
     init_chat_context_fixed_service();
     init_conversation_persistence();
     init_ai_response_tetris_template();
+    init_intent();
+    init_provider_factory();
+    init_feature_flags();
+    init_telemetry_collector();
+    init_context();
+    init_code();
+    init_continuation();
+    init_question();
+    init_safety();
     AIResponseService = class {
       chatContext;
-      conversationPersistence;
+      _conversationPersistence;
+      providerFactory;
+      telemetry;
+      initialized = false;
       constructor() {
         this.chatContext = ChatContextService.getInstance();
-        this.conversationPersistence = new ConversationPersistence();
+        this._conversationPersistence = new ConversationPersistence();
+        this.providerFactory = AIProviderFactory.getInstance();
+        this.telemetry = TelemetryCollector.getInstance();
+        this.initializeProviders().catch(console.error);
+      }
+      /**
+       * Initialize AI providers based on configuration
+       */
+      async initializeProviders() {
+        if (this.initialized) return;
+        try {
+          await this.providerFactory.initializeFromEnvironment();
+          this.initialized = true;
+          console.log("[AI Response Service] Providers initialized");
+        } catch (error2) {
+          console.error("[AI Response Service] Provider initialization failed:", error2);
+        }
       }
       /**
-       * Generate intelligent AI response using actual providers
-       * Replaces the hard-coded template system
+       * Generate intelligent AI response with multi-language support and safety guards
+       * v3.0 - Complete rewrite with modular architecture
        */
       async generateResponse(request2, options2 = {}) {
+        const startTime = Date.now();
         try {
+          const inputSafety = checkInputSafety(request2.userInput);
+          if (!inputSafety.safe) {
+            logSafetyEvent({ type: "input_check", safe: false, reason: inputSafety.reason });
+            const lang = detectLanguage(request2.userInput);
+            return generateRejectionMessage(inputSafety.reason || "Safety check failed", lang === "ja");
+          }
           await this.chatContext.addMessage({
             role: "user",
             content: request2.userInput
           });
-          const context2 = this.buildContextForAI(request2);
-          const aiResponse = await this.callAIProvider(context2, options2);
+          const context2 = buildContextForAI(
+            request2.sessionMemory,
+            {
+              budgetChars: options2.contextLength ? options2.contextLength * 4 : 8e3,
+              maxMessages: 20
+            }
+          );
+          const language2 = detectLanguage(request2.userInput);
+          const recentText = context2.recentMessages.map((m2) => m2.content).join(" ");
+          const intent2 = analyzeIntent(request2.userInput, recentText);
+          if (featureFlags.isEnabled("enableTelemetry")) {
+            this.telemetry.trackIntent({
+              type: intent2.type,
+              confidence: intent2.confidence,
+              language: language2,
+              timestamp: Date.now()
+            });
+          }
+          let aiResponse;
+          const config2 = featureFlags.getAIResponseConfig();
+          if (config2.useRealProviders && intent2.type !== "TETRIS_REQUEST") {
+            aiResponse = await this.generateWithProvider(
+              request2.userInput,
+              context2,
+              language2,
+              options2
+            );
+          } else {
+            aiResponse = await this.routeByIntent(
+              intent2,
+              request2.userInput,
+              context2,
+              { language: language2, options: options2 }
+            );
+          }
+          const outputSafety = checkOutputSafety(aiResponse);
+          const finalResponse = outputSafety.safe ? aiResponse : sanitizeOutput(aiResponse, 5e4);
           await this.chatContext.addMessage({
             role: "assistant",
-            content: aiResponse
+            content: finalResponse
           });
-          return aiResponse;
+          const latency = Date.now() - startTime;
+          if (featureFlags.isEnabled("enableTelemetry")) {
+            this.telemetry.trackResponse({
+              provider: config2.useRealProviders ? config2.providerType : "template",
+              model: "unknown",
+              // Would need to get from provider
+              latencyMs: latency,
+              success: true,
+              fallback: !config2.useRealProviders,
+              timestamp: Date.now()
+            });
+          }
+          return finalResponse;
         } catch (error2) {
           console.error("AI Response generation failed:", error2);
+          logSafetyEvent({ type: "rejection", safe: false, reason: "Generation failed" });
+          if (featureFlags.isEnabled("enableTelemetry")) {
+            this.telemetry.trackError(error2, {
+              userInput: request2.userInput,
+              provider: "unknown"
+            });
+          }
           return this.generateFallbackResponse(request2.userInput);
         }
       }
       /**
-       * Build context for AI provider
-       */
-      buildContextForAI(request2) {
-        const recentContext = request2.sessionMemory.slice(-5);
-        return {
-          messages: recentContext.map((msg2) => ({
-            role: msg2.role,
-            content: msg2.content
-          })),
-          currentInput: request2.userInput,
-          contextStats: this.chatContext.getStats()
-        };
-      }
-      /**
-       * Call actual AI provider with intelligent intent recognition
+       * Route request to appropriate responder based on intent
+       * v3.0 - New routing logic with language awareness
        */
-      async callAIProvider(context2, _options) {
-        const userInput2 = context2.currentInput.toLowerCase();
-        const hasContext = context2.messages.length > 0;
-        const intent2 = this.analyzeIntent(userInput2, context2);
+      async routeByIntent(intent2, userInput2, context2, config2) {
+        const { language: language2 } = config2;
+        const isJapanese = language2 === "ja";
+        const topics = extractKeyTopics(context2);
         switch (intent2.type) {
           case "TETRIS_REQUEST":
-            return this.generateTetrisGame(userInput2);
+            if (isExplicitContentAllowed(userInput2, "tetris")) {
+              return generateTetrisGameTemplate(userInput2);
+            }
+            return this.generateDefaultResponse(userInput2);
           case "CODE_REQUEST":
-            return this.generateCodeResponse(userInput2, context2);
+            if (userInput2.toLowerCase().includes("cli")) {
+              return generateCLITemplate(isJapanese);
+            }
+            if (userInput2.toLowerCase().includes("api") || userInput2.toLowerCase().includes("next")) {
+              return generateNextAPITemplate(isJapanese);
+            }
+            return buildCodeResponse({
+              title: isJapanese ? "\u30B3\u30FC\u30C9\u5B9F\u88C5\u4F8B" : "Code Implementation",
+              files: [{
+                path: "example.ts",
+                lang: "typescript",
+                content: `// Your implementation here
+console.log('Hello World');`
+              }],
+              runCommands: isJapanese ? ["\u30D5\u30A1\u30A4\u30EB\u3092\u4F5C\u6210", "node example.js \u3067\u5B9F\u884C"] : ["Create the file", "Run with node example.js"],
+              isJapanese
+            });
           case "QUESTION":
-            return this.generateQuestionResponse(userInput2, context2);
+            return buildComprehensiveAnswer(userInput2, topics, isJapanese);
           case "CONTINUATION":
-            return this.generateContinuationResponse(userInput2, context2);
+            const contextPreview = context2.recentMessages.slice(-3).map((m2) => m2.content).join(" ");
+            return buildSmartContinuation(contextPreview, topics, isJapanese);
+          case "SUMMARIZE":
+            return this.generateSummaryResponse(context2, isJapanese);
+          case "REFACTOR":
+            return this.generateRefactorResponse(userInput2, isJapanese);
           default:
-            if (hasContext) {
-              return this.generateContextualResponse(userInput2, context2);
-            }
-            return this.generateDefaultResponse(userInput2);
-        }
-      }
-      /**
-       * Enhanced intent analysis with context awareness
-       */
-      analyzeIntent(userInput2, context2) {
-        const messages2 = context2.messages || [];
-        const recentMessages2 = messages2.slice(-3);
-        const contextString = recentMessages2.map((m2) => m2.content).join(" ").toLowerCase();
-        if (userInput2.includes("tetris")) {
-          return {
-            type: "TETRIS_REQUEST",
-            confidence: 0.9,
-            context: "User wants Tetris game code"
-          };
-        }
-        if (this.isCodeRequest(userInput2)) {
-          return {
-            type: "CODE_REQUEST",
-            confidence: 0.8,
-            context: "User wants code implementation"
-          };
+            return this.generateSmartDefault(userInput2, topics, isJapanese);
         }
-        if (contextString.length > 0 && (userInput2.includes("whole code") || userInput2.includes("complete") || userInput2.includes("start") || userInput2.includes("give me"))) {
-          return {
-            type: "CONTINUATION",
-            confidence: 0.7,
-            context: "User continuing previous conversation"
-          };
-        }
-        if (this.isQuestionRequest(userInput2)) {
-          return {
-            type: "QUESTION",
-            confidence: 0.6,
-            context: "User asking a question"
-          };
-        }
-        return {
-          type: "GENERAL",
-          confidence: 0.3,
-          context: "General conversation"
-        };
       }
       /**
-       * Generate continuation response based on context
+       * Generate summary response
        */
-      generateContinuationResponse(_input, context2) {
-        const messages2 = context2.messages || [];
-        const recentMessages2 = messages2.slice(-3);
-        const contextString = recentMessages2.map((m2) => m2.content).join(" ");
-        return `Got it \u2014 you'd like to continue from our recent context.
+      generateSummaryResponse(context2, isJapanese) {
+        const stats2 = getContextStats(context2);
+        const topics = stats2.topics.join(", ") || (isJapanese ? "\u4E00\u822C\u7684\u306A\u4F1A\u8A71" : "general conversation");
+        return isJapanese ? `\u76F4\u8FD1\u306E\u4F1A\u8A71\u3092\u8981\u7D04\u3057\u307E\u3059\uFF1A
 
-Recent context (last few messages):
-${contextString.substring(0, 200)}${contextString.length > 200 ? "..." : ""}
+\u{1F4CA} **\u7D71\u8A08\u60C5\u5831**
+\u2022 \u30E1\u30C3\u30BB\u30FC\u30B8\u6570: ${stats2.messageCount}
+\u2022 \u5408\u8A08\u6587\u5B57\u6570: ${stats2.totalChars}
+\u2022 \u30C8\u30D4\u30C3\u30AF: ${topics}
 
-Please tell me the **exact next step** you want (e.g., "add error handling", "extract function", "write tests", "explain the trade-offs").`;
-      }
-      /**
-       * Detect if user is asking for code/implementation
-       */
-      isCodeRequest(input3) {
-        const codeKeywords = ["implement", "create", "build", "code", "function", "class", "html", "css", "javascript", "python", "typescript"];
-        return codeKeywords.some((keyword) => input3.includes(keyword));
-      }
-      /**
-       * Detect if user is asking a question
-       */
-      isQuestionRequest(input3) {
-        const questionWords = ["what", "how", "why", "when", "where", "which", "who"];
-        return questionWords.some((word) => input3.startsWith(word)) || input3.includes("?");
-      }
-      /**
-       * Generate code-focused response
-       */
-      generateCodeResponse(input3, _context) {
-        if (input3.includes("tetris") && (input3.includes("html") || input3.includes("index"))) {
-          return this.generateTetrisGame(input3);
-        }
-        return `I understand you want to implement something with code. Let me help you build it step by step.
+\u{1F4DD} **\u8981\u7D04**
+${context2.rollingSummary || "\u8981\u7D04\u3059\u308B\u5185\u5BB9\u304C\u4E0D\u8DB3\u3057\u3066\u3044\u307E\u3059\u3002"}
 
-Based on your request, I'll provide:
-\u2022 Clean, well-commented code
-\u2022 Best practices implementation  
-\u2022 Error handling and edge cases
-\u2022 Testing suggestions
+\u6B21\u306E\u30B9\u30C6\u30C3\u30D7\u3092\u9078\u3093\u3067\u304F\u3060\u3055\u3044\uFF1A
+1) \u8A73\u7D30\u306A\u8981\u7D04\u3092\u898B\u308B
+2) \u7279\u5B9A\u306E\u30C8\u30D4\u30C3\u30AF\u306B\u7D5E\u308B
+3) \u65B0\u3057\u3044\u8CEA\u554F\u3092\u3059\u308B` : `Here's a summary of our recent conversation:
 
-What specific functionality would you like me to focus on first?`;
-      }
-      /**
-       * Generate complete Tetris game code
-       */
-      generateTetrisGame(input3) {
-        return generateTetrisGameTemplate(input3);
+\u{1F4CA} **Statistics**
+\u2022 Messages: ${stats2.messageCount}
+\u2022 Total chars: ${stats2.totalChars}  
+\u2022 Topics: ${topics}
+
+\u{1F4DD} **Summary**
+${context2.rollingSummary || "Not enough content to summarize."}
+
+Choose your next step:
+1) See detailed summary
+2) Focus on specific topic
+3) Ask a new question`;
       }
       /**
-       * Generate question-focused response
+       * Generate refactoring suggestions
        */
-      generateQuestionResponse(input3, _context) {
-        return `That's a great question! Let me provide you with a comprehensive answer.
+      generateRefactorResponse(input3, isJapanese) {
+        return isJapanese ? `\u30EA\u30D5\u30A1\u30AF\u30BF\u30EA\u30F3\u30B0\u306E\u3054\u8981\u671B\u3067\u3059\u306D\u3002\u300C${input3.substring(0, 50)}\u300D\u3092\u6539\u5584\u3057\u307E\u3059\u3002
 
-Based on your question about "${input3.substring(0, 50)}...", I'll explain:
+**\u6539\u5584\u30DD\u30A4\u30F3\u30C8**
+1) \u53EF\u8AAD\u6027\u306E\u5411\u4E0A\uFF08\u5909\u6570\u540D\u30FB\u95A2\u6570\u540D\u306E\u6539\u5584\uFF09
+2) \u30D1\u30D5\u30A9\u30FC\u30DE\u30F3\u30B9\u306E\u6700\u9069\u5316
+3) \u91CD\u8907\u30B3\u30FC\u30C9\u306E\u524A\u9664
+4) \u30C7\u30B6\u30A4\u30F3\u30D1\u30BF\u30FC\u30F3\u306E\u9069\u7528
 
-\u2022 The technical background and concepts
-\u2022 Practical implementation details
-\u2022 Best practices and common pitfalls
-\u2022 Real-world examples and use cases
+\u3069\u306E\u89B3\u70B9\u304B\u3089\u59CB\u3081\u307E\u3059\u304B\uFF1F\uFF081-4\u3067\u9078\u629E\uFF09` : `I'll help you refactor "${input3.substring(0, 50)}".
 
-Would you like me to focus on any particular aspect of this topic?`;
+**Improvement areas**
+1) Readability (better naming)
+2) Performance optimization
+3) Remove duplication
+4) Apply design patterns
+
+Which aspect should we start with? (Choose 1-4)`;
       }
       /**
-       * Generate contextual response based on conversation history
+       * Generate smart default response with choices
        */
-      generateContextualResponse(input3, context2) {
-        const previousTopics = context2.messages.filter((msg2) => msg2.role === "user").map((msg2) => msg2.content.substring(0, 50)).join(", ");
-        return `I see we've been discussing: ${previousTopics}
+      generateSmartDefault(input3, topics, isJapanese) {
+        const cleanInput = input3.substring(0, 100);
+        const options2 = isJapanese ? [
+          "\u4ECA\u3059\u3050\u52D5\u304F\u6700\u5C0F\u30B3\u30FC\u30C9",
+          "\u8A2D\u8A08\u65B9\u91DD\u3068\u30C8\u30EC\u30FC\u30C9\u30AA\u30D5",
+          "\u65E2\u5B58\u30B3\u30FC\u30C9\u306E\u6539\u5584\u63D0\u6848",
+          "\u8A73\u7D30\u306A\u8AAC\u660E\u3092\u805E\u304F"
+        ] : [
+          "Minimal working code",
+          "Design & trade-offs",
+          "Improve existing code",
+          "Detailed explanation"
+        ];
+        const topicNote = topics.length > 0 ? isJapanese ? `
+\u691C\u51FA\u3055\u308C\u305F\u30C8\u30D4\u30C3\u30AF: ${topics.join(", ")}` : `
+Detected topics: ${topics.join(", ")}` : "";
+        return isJapanese ? `\u3054\u4F9D\u983C\u3042\u308A\u304C\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002\u300C${cleanInput}\u300D\u306B\u3064\u3044\u3066\u5BFE\u5FDC\u3057\u307E\u3059\u3002${topicNote}
 
-Regarding your latest message: "${input3}"
+\u6700\u77ED\u3067\u76EE\u7684\u3092\u9054\u6210\u3059\u308B\u305F\u3081\u3001\u4EE5\u4E0B\u304B\u3089\u9078\u3093\u3067\u304F\u3060\u3055\u3044\uFF1A
+${options2.map((opt, i2) => `${i2 + 1}) ${opt}`).join("\n")}
 
-Let me build on our previous conversation and provide a detailed response that addresses your specific needs. I'll make sure to connect this to what we've already covered.
+\u756A\u53F7\u3067\u6307\u793A\u3057\u3066\u304F\u3060\u3055\u3044\uFF081-4\uFF09\u3002` : `Thanks for your request: "${cleanInput}"${topicNote}
 
-What specific aspect would you like me to elaborate on?`;
+Choose your fastest path to success:
+${options2.map((opt, i2) => `${i2 + 1}) ${opt}`).join("\n")}
+
+Reply with a number (1-4).`;
+      }
+      /**
+       * Generate response using real AI provider
+       */
+      async generateWithProvider(userInput2, context2, language2, options2) {
+        try {
+          const provider2 = await this.providerFactory.getActiveProvider();
+          const messages2 = [];
+          messages2.push({
+            role: "system",
+            content: language2 === "ja" ? "\u3042\u306A\u305F\u306F\u89AA\u5207\u3067\u77E5\u8B58\u8C4A\u5BCC\u306A\u30A2\u30B7\u30B9\u30BF\u30F3\u30C8\u3067\u3059\u3002\u65E5\u672C\u8A9E\u3067\u4E01\u5BE7\u306B\u56DE\u7B54\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u30B3\u30FC\u30C9\u3092\u63D0\u4F9B\u3059\u308B\u5834\u5408\u306F\u3001\u5B9F\u884C\u624B\u9806\u3082\u542B\u3081\u3066\u304F\u3060\u3055\u3044\u3002" : "You are a helpful and knowledgeable assistant. Provide clear, actionable responses. When providing code, include execution instructions."
+          });
+          if (context2.rollingSummary) {
+            messages2.push({
+              role: "system",
+              content: `Previous context summary: ${context2.rollingSummary}`
+            });
+          }
+          context2.recentMessages.forEach((msg2) => {
+            messages2.push({
+              role: msg2.role,
+              content: msg2.content
+            });
+          });
+          const lastMessage2 = context2.recentMessages[context2.recentMessages.length - 1];
+          if (!lastMessage2 || lastMessage2.content !== userInput2) {
+            messages2.push({
+              role: "user",
+              content: userInput2
+            });
+          }
+          const response2 = await provider2.generateCompletion({
+            messages: messages2,
+            temperature: options2.temperature,
+            maxTokens: options2.contextLength,
+            streaming: options2.streaming && featureFlags.isEnabled("enableStreaming")
+          });
+          const footer = language2 === "ja" ? "\n\n\u6B21\u306E\u30B9\u30C6\u30C3\u30D7\u3092\u304A\u9078\u3073\u304F\u3060\u3055\u3044\uFF1A\n1) \u8A73\u7D30\u3092\u898B\u308B\n2) \u5B9F\u88C5\u3092\u958B\u59CB\n3) \u5225\u306E\u8CEA\u554F" : "\n\nChoose next step:\n1) See details\n2) Start implementation\n3) Different question";
+          return response2.content + footer;
+        } catch (error2) {
+          console.error("[AI Response] Provider generation failed:", error2);
+          return this.routeByIntent(
+            analyzeIntent(userInput2, ""),
+            userInput2,
+            context2,
+            { language: language2, options: options2 }
+          );
+        }
       }
       /**
-       * Generate default intelligent response
+       * Generate default response (kept for compatibility)
        */
       generateDefaultResponse(input3) {
-        return `Thank you for your message: "${input3}"
+        const lang = detectLanguage(input3);
+        const isJapanese = lang === "ja";
+        return isJapanese ? `\u300C${input3.substring(0, 50)}\u300D\u306B\u3064\u3044\u3066\u5BFE\u5FDC\u3044\u305F\u3057\u307E\u3059\u3002
 
-I'm ready to help you with:
-\u2022 Technical implementation and coding
-\u2022 Problem-solving and debugging  
-\u2022 Architecture and design decisions
-\u2022 Best practices and optimization
+\u4EE5\u4E0B\u304B\u3089\u304A\u9078\u3073\u304F\u3060\u3055\u3044\uFF1A
+1) \u5B9F\u88C5\u65B9\u6CD5\u3092\u898B\u308B
+2) \u6982\u5FF5\u3092\u7406\u89E3\u3059\u308B
+3) \u554F\u984C\u3092\u89E3\u6C7A\u3059\u308B
 
-How can I assist you with this request?`;
+\u756A\u53F7\u3067\u304A\u7B54\u3048\u304F\u3060\u3055\u3044\u3002` : `I'll help you with: "${input3.substring(0, 50)}"
+
+Choose an option:
+1) See implementation
+2) Understand concepts
+3) Solve problems
+
+Reply with a number.`;
       }
       /**
-       * Fallback response for errors
+       * Fallback response for errors with language detection
        */
       generateFallbackResponse(input3) {
-        return `I apologize, but I encountered an issue processing your request: "${input3}"
+        const lang = detectLanguage(input3);
+        const isJapanese = lang === "ja";
+        return isJapanese ? `\u7533\u3057\u8A33\u3054\u3056\u3044\u307E\u305B\u3093\u3002\u300C${input3.substring(0, 50)}\u300D\u306E\u51E6\u7406\u4E2D\u306B\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F\u3002
+
+\u5225\u306E\u65B9\u6CD5\u3067\u304A\u624B\u4F1D\u3044\u3057\u307E\u3059\uFF1A
+\u2022 \u8CEA\u554F\u3092\u8A00\u3044\u63DB\u3048\u3066\u304F\u3060\u3055\u3044
+\u2022 \u3088\u308A\u5177\u4F53\u7684\u306A\u8A73\u7D30\u3092\u63D0\u4F9B\u3057\u3066\u304F\u3060\u3055\u3044
+\u2022 \u8907\u96D1\u306A\u30EA\u30AF\u30A8\u30B9\u30C8\u306F\u5C0F\u3055\u304F\u5206\u5272\u3057\u3066\u304F\u3060\u3055\u3044
+
+\u52B9\u679C\u7684\u306B\u30B5\u30DD\u30FC\u30C8\u3055\u305B\u3066\u3044\u305F\u3060\u304D\u307E\u3059\uFF01` : `I apologize, but I encountered an issue processing: "${input3.substring(0, 50)}"
 
-Let me try to help you in a different way. Could you please:
-\u2022 Rephrase your question or request
-\u2022 Provide more specific details about what you need
-\u2022 Break down complex requests into smaller parts
+Let me help you differently:
+\u2022 Rephrase your question
+\u2022 Provide more specific details
+\u2022 Break down complex requests
 
 I'm here to assist you effectively!`;
       }
@@ -37725,8 +40370,8 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@bonginkan/maria",
-      version: "3.1.4",
-      description: "\u{1F680} MARIA v3.1.4 - Minimal API, Maximum Power. Enterprise-ready AI development platform with beautiful CLI experience and rock-solid stability.",
+      version: "3.1.6",
+      description: "\u{1F4CA} MARIA v3.1.6 - Advanced Telemetry & Analytics. Enterprise AI platform with ML-powered monitoring, predictive analytics, and real-time insights.",
       keywords: [
         "ai",
         "cli",