activo 0.4.2 → 0.4.4

package/src/core/agent.ts

@@ -1,6 +1,7 @@
+import * as fs from "fs";
 import { OllamaClient, ChatMessage } from "./llm/ollama.js";
 import { Config } from "./config.js";
-import { getAllTools, executeTool, ToolCall, ToolResult, Tool } from "./tools/index.js";
+import { getAllTools, selectTools, executeTool, ToolCall, ToolResult, Tool } from "./tools/index.js";
 
 export interface AgentEvent {
   type: "thinking" | "content" | "tool_use" | "tool_result" | "done" | "error";
@@ -23,52 +24,11 @@ export interface AgentResult {
 
 const BASE_SYSTEM_PROMPT = `You are ACTIVO, a code quality analyzer. You MUST call tools to perform tasks.
 
-## CRITICAL RULES
+## RULES
 1. Call tool IMMEDIATELY when user requests an action
-2. NEVER output text before calling a tool
-3. NEVER fabricate results - only report actual tool output
-4. After tool returns, summarize in user's language (Korean if user speaks Korean)
-
-## TOOLS BY CATEGORY
-
-### Document Conversion & RAG
-- import_hwp_standards(hwpPath, outputDir): Convert HWP to markdown
-- import_pdf_standards(pdfPath, outputDir): Convert PDF to markdown
-- index_standards(directory?): Index standards for RAG search (run after import)
-- search_standards(query, topK?): Search standards by semantic query
-- check_quality_rag(filepath, topK?): Check code using RAG to find relevant standards
-
-### Code Analysis (Recommended: use analyze_all)
-- analyze_all(path, include?): Analyze all code (Java/JS/TS/Python)
-- java_analyze(path): Java code analysis
-- java_complexity(path): Java complexity metrics
-- spring_check(path): Spring pattern check
-- ast_analyze(path): JS/TS AST analysis
-- react_check(path): React pattern check
-- vue_check(path): Vue pattern check
-- python_check(path): Python code analysis
-
-### SQL/DB Analysis
-- sql_check(path): SQL query analysis
-- mybatis_check(path): MyBatis mapper analysis
-
-### Web Analysis
-- css_check(path): CSS analysis
-- html_check(path): HTML analysis
-- dependency_check(path): package.json dependency analysis
-- openapi_check(path): OpenAPI spec analysis
-
-### File Operations
-- read_file(path): Read file content
-- write_file(path, content): Write file
-- list_directory(path): List directory contents
-- grep_search(pattern, path): Search pattern in files
-- glob_search(pattern): Search files by pattern
-
-## EXAMPLE
-User: "Analyze src folder"
-→ Call analyze_all(path="src") immediately
-→ After result: Summarize findings`;
+2. NEVER fabricate results - only report actual tool output
+3. After tool returns, summarize in user's language (Korean if user speaks Korean)
+4. Use analyze_all for broad code analysis`;
 
 // Build system prompt with optional context
 function buildSystemPrompt(contextSummary?: string): string {
@@ -86,6 +46,396 @@ ${contextSummary}
 위 내용은 이전 세션에서의 대화 요약입니다. 필요시 참고하세요.`;
 }
 
+// ─── Intent Router ───
+
+interface IntentResult {
+  handled: boolean;
+  toolName?: string;
+  toolArgs?: Record<string, unknown>;
+  toolResult?: ToolResult;
+  summaryPrompt?: string;
+}
+
+interface IntentPattern {
+  keywords: string[];
+  tool: string;
+  buildArgs: (path: string, message: string) => Record<string, unknown>;
+}
+
+// Intent patterns: keyword groups → tool + args builder
+const INTENT_PATTERNS: IntentPattern[] = [
+  // Single file analysis (must come before directory patterns)
+  {
+    keywords: ["분석", "analyze", "검사", "check"],
+    tool: "_single_file",  // special marker - resolved at match time
+    buildArgs: (path: string) => ({ filepath: path }),
+  },
+  // analyze_all with Java filter
+  {
+    keywords: ["자바", "java"],
+    tool: "analyze_all",
+    buildArgs: (path: string) => ({ path, include: ["java"] }),
+  },
+  // Spring patterns
+  {
+    keywords: ["spring", "스프링"],
+    tool: "analyze_all",
+    buildArgs: (path: string) => ({ path, include: ["java"] }),
+  },
+  // Dependency analysis
+  {
+    keywords: ["의존성", "dependency", "dependencies", "취약점"],
+    tool: "dependency_check",
+    buildArgs: (path: string) => ({ path }),
+  },
+  // Complexity
+  {
+    keywords: ["복잡도", "complexity"],
+    tool: "analyze_all",
+    buildArgs: (path: string) => ({ path }),
+  },
+  // Python
+  {
+    keywords: ["python", "파이썬", ".py"],
+    tool: "analyze_all",
+    buildArgs: (path: string) => ({ path, include: ["py"] }),
+  },
+  // Frontend
+  {
+    keywords: ["react", "리액트", "vue", "뷰", "프론트엔드", "frontend"],
+    tool: "analyze_all",
+    buildArgs: (path: string) => ({ path, include: ["js", "ts", "jsx", "tsx", "vue"] }),
+  },
+  // CSS
+  {
+    keywords: ["css", "scss", "less", "스타일"],
+    tool: "analyze_all",
+    buildArgs: (path: string) => ({ path, include: ["css"] }),
+  },
+  // HTML
+  {
+    keywords: ["html", "jsp", "접근성", "a11y", "seo"],
+    tool: "analyze_all",
+    buildArgs: (path: string) => ({ path, include: ["html"] }),
+  },
+  // SQL / MyBatis
+  {
+    keywords: ["sql", "mybatis", "마이바티스", "쿼리"],
+    tool: "analyze_all",
+    buildArgs: (path: string) => ({ path, include: ["java", "xml"] }),
+  },
+  // Broad analysis (catch-all, must be last)
+  {
+    keywords: ["전체분석", "전체 분석", "분석해", "코드품질", "코드 품질", "analyze", "분석", "검사", "check"],
+    tool: "analyze_all",
+    buildArgs: (path: string) => ({ path }),
+  },
+];
+
+// File extension → single-file tool mapping
+const FILE_TOOL_MAP: Record<string, string> = {
+  ".java": "java_analyze",
+  ".js": "ast_analyze",
+  ".ts": "ast_analyze",
+  ".jsx": "react_check",
+  ".tsx": "react_check",
+  ".vue": "vue_check",
+  ".py": "python_check",
+  ".css": "css_check",
+  ".scss": "css_check",
+  ".less": "css_check",
+  ".html": "html_check",
+  ".htm": "html_check",
+  ".jsp": "html_check",
+};
+
+/**
+ * Extract filesystem paths from user message.
+ * Handles quoted paths (with spaces), simple paths, and greedy path expansion.
+ */
+function extractPaths(message: string): string[] {
+  const paths: string[] = [];
+
+  // 1. Quoted paths: '...' or "..."
+  const quotedMatches = message.match(/['"]([/\\][^'"]+)['"]/g);
+  if (quotedMatches) {
+    for (const m of quotedMatches) {
+      paths.push(m.slice(1, -1)); // strip quotes
+    }
+  }
+
+  // 2. Simple paths (no spaces) - Unix & Windows
+  const unixMatches = message.match(/(?:^|\s)(\/[^\s,;:'"]+)/g);
+  if (unixMatches) {
+    for (const m of unixMatches) {
+      paths.push(m.trim());
+    }
+  }
+  const winMatches = message.match(/(?:^|\s)([A-Z]:\\[^\s,;:'"]+)/gi);
+  if (winMatches) {
+    for (const m of winMatches) {
+      paths.push(m.trim());
+    }
+  }
+
+  // 3. Greedy path expansion: if simple match doesn't exist,
+  //    try extending with subsequent words until path is valid
+  if (paths.length === 0 || !paths.some((p) => { try { return fs.existsSync(p); } catch { return false; } })) {
+    const words = message.split(/\s+/);
+    for (let i = 0; i < words.length; i++) {
+      if (words[i].startsWith("/") || /^[A-Z]:\\/i.test(words[i])) {
+        // Found a path start, try extending
+        let candidate = words[i];
+        let bestPath = "";
+        // Check initial segment
+        try { if (fs.existsSync(candidate)) bestPath = candidate; } catch { /* */ }
+        // Extend with subsequent words
+        for (let j = i + 1; j < words.length; j++) {
+          const extended = candidate + " " + words[j];
+          try {
+            if (fs.existsSync(extended)) {
+              bestPath = extended;
+              candidate = extended;
+            } else {
+              // No more valid extensions - stop
+              break;
+            }
+          } catch {
+            break;
+          }
+        }
+        if (bestPath) {
+          paths.push(bestPath);
+        }
+      }
+    }
+  }
+
+  // Filter to actually existing paths, deduplicate
+  const seen = new Set<string>();
+  return paths.filter((p) => {
+    if (seen.has(p)) return false;
+    seen.add(p);
+    try {
+      return fs.existsSync(p);
+    } catch {
+      return false;
+    }
+  });
+}
+
+/**
+ * Determine if a path is a single file (not a directory).
+ */
+function isSingleFile(p: string): boolean {
+  try {
+    return fs.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Resolve the correct tool for a single file based on extension.
+ */
+function resolveFileAnalysisTool(filepath: string): { tool: string; args: Record<string, unknown> } | null {
+  const ext = filepath.substring(filepath.lastIndexOf(".")).toLowerCase();
+  const toolName = FILE_TOOL_MAP[ext];
+  if (!toolName) return null;
+
+  // Some tools use 'filepath', others use 'path'
+  const argKey = ["python_check", "css_check", "html_check"].includes(toolName) ? "path" : "filepath";
+  return { tool: toolName, args: { [argKey]: filepath } };
+}
+
+/**
+ * Detect user intent from the message and automatically execute the appropriate tool.
+ * Returns IntentResult with handled=true if a tool was executed, false otherwise.
+ */
+async function detectAndExecuteIntent(
+  userMessage: string,
+  onEvent?: (event: AgentEvent) => void
+): Promise<IntentResult> {
+  const msg = userMessage.toLowerCase();
+  const paths = extractPaths(userMessage);
+
+  // No path found → can't auto-route
+  if (paths.length === 0) {
+    return { handled: false };
+  }
+
+  const targetPath = paths[0];
+
+  // Check if path is a single file
+  if (isSingleFile(targetPath)) {
+    const fileInfo = resolveFileAnalysisTool(targetPath);
+    if (fileInfo) {
+      return await executeIntentTool(fileInfo.tool, fileInfo.args, onEvent);
+    }
+    // Unknown file type → fall back to LLM
+    return { handled: false };
+  }
+
+  // Path is a directory → match intent patterns
+  for (const pattern of INTENT_PATTERNS) {
+    // Skip the single-file marker for directories
+    if (pattern.tool === "_single_file") continue;
+
+    if (pattern.keywords.some((kw) => msg.includes(kw))) {
+      const args = pattern.buildArgs(targetPath, userMessage);
+      return await executeIntentTool(pattern.tool, args, onEvent);
+    }
+  }
+
+  // Has a directory path but no matching keyword → default to analyze_all
+  // (user likely wants some kind of analysis if they provided a path)
+  const hasAnalysisHint = /분석|검사|확인|체크|check|analyze|review|scan|report/i.test(msg);
+  if (hasAnalysisHint) {
+    return await executeIntentTool("analyze_all", { path: targetPath }, onEvent);
+  }
+
+  return { handled: false };
+}
+
+/**
+ * Execute a tool by name and return an IntentResult with the summary prompt.
+ */
+async function executeIntentTool(
+  toolName: string,
+  toolArgs: Record<string, unknown>,
+  onEvent?: (event: AgentEvent) => void
+): Promise<IntentResult> {
+  const toolCall: ToolCall = {
+    id: `intent_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+    name: toolName,
+    arguments: toolArgs,
+  };
+
+  // Emit tool_use start event
+  onEvent?.({
+    type: "tool_use",
+    tool: toolName,
+    status: "start",
+    args: toolArgs,
+  });
+
+  const result = await executeTool(toolCall);
+
+  // Emit tool_result event
+  onEvent?.({
+    type: "tool_result",
+    tool: toolName,
+    status: result.success ? "complete" : "error",
+    result,
+  });
+
+  if (!result.success) {
+    return {
+      handled: true,
+      toolName,
+      toolArgs,
+      toolResult: result,
+      summaryPrompt: `도구 "${toolName}" 실행 중 오류가 발생했습니다: ${result.error}\n사용자에게 오류 내용을 설명해주세요.`,
+    };
+  }
+
+  // Compress result to fit in context window
+  const compressed = compressAnalysisResult(result.content);
+
+  return {
+    handled: true,
+    toolName,
+    toolArgs,
+    toolResult: result,
+    summaryPrompt: `아래는 "${toolName}" 도구의 실행 결과입니다. 사용자에게 한국어로 핵심 내용을 요약해주세요.\n\n${compressed}`,
+  };
+}
+
+/**
+ * Compress analysis result JSON to fit within LLM context window.
+ * Extracts only key metrics, removing verbose raw data.
+ */
+function compressAnalysisResult(resultContent: string, maxChars: number = 2000): string {
+  try {
+    const parsed = JSON.parse(resultContent);
+
+    // analyze_all result
+    if (parsed.path && parsed.fileStats) {
+      const compact: Record<string, unknown> = {
+        path: parsed.path,
+        totalFiles: parsed.totalFiles,
+        fileStats: parsed.fileStats,
+        analysesRun: parsed.analysesRun,
+        successful: parsed.successful,
+        failed: parsed.failed,
+      };
+
+      // Extract issue summaries (compact)
+      if (parsed.issuesSummary?.length > 0) {
+        compact.issues = parsed.issuesSummary.map((is: { tool: string; issues: string[] }) => ({
+          tool: is.tool,
+          issues: is.issues.slice(0, 5),
+        }));
+      }
+
+      // Extract per-tool summaries (key metrics only)
+      if (parsed.details?.length > 0) {
+        compact.analyses = parsed.details.map((d: { tool: string; summary: Record<string, unknown> }) => {
+          const s = d.summary;
+          const brief: Record<string, unknown> = { tool: d.tool };
+
+          // Extract numeric/small fields only
+          for (const [k, v] of Object.entries(s)) {
+            if (typeof v === "number" || typeof v === "boolean") {
+              brief[k] = v;
+            } else if (typeof v === "string" && v.length < 100) {
+              brief[k] = v;
+            }
+            // Skip arrays/objects (raw data) to save space
+          }
+
+          // Include issues from samples (java_analyze etc.)
+          if (Array.isArray((s as any).samples)) {
+            const allIssues: unknown[] = [];
+            for (const sample of (s as any).samples) {
+              if (Array.isArray(sample.result?.issues)) {
+                allIssues.push(...sample.result.issues.slice(0, 3));
+              }
+            }
+            if (allIssues.length > 0) {
+              brief.issues = allIssues.slice(0, 10);
+            }
+          }
+
+          return brief;
+        });
+      }
+
+      if (parsed.errors?.length > 0) {
+        compact.errors = parsed.errors;
+      }
+
+      const result = JSON.stringify(compact, null, 1);
+      return result.length > maxChars ? result.slice(0, maxChars) + "..." : result;
+    }
+
+    // java_analyze or other single-file results
+    if (parsed.file || parsed.filepath || parsed.classes || parsed.functions) {
+      const result = JSON.stringify(parsed, null, 1);
+      return result.length > maxChars ? result.slice(0, maxChars) + "..." : result;
+    }
+
+    // Generic: just truncate
+    const result = JSON.stringify(parsed, null, 1);
+    return result.length > maxChars ? result.slice(0, maxChars) + "..." : result;
+  } catch {
+    // Not valid JSON, return truncated raw text
+    return resultContent.length > maxChars ? resultContent.slice(0, maxChars) + "..." : resultContent;
+  }
+}
+
+// ─── Main processing functions ───
+
 export async function processMessage(
   userMessage: string,
   history: ChatMessage[],
@@ -94,7 +444,33 @@ export async function processMessage(
   onEvent?: (event: AgentEvent) => void,
   contextSummary?: string
 ): Promise<AgentResult> {
-  const tools = getAllTools();
+  // Try intent router first
+  const intent = await detectAndExecuteIntent(userMessage, onEvent);
+
+  if (intent.handled && intent.summaryPrompt) {
+    // Tool already executed → ask LLM to summarize only (no tools = VRAM savings)
+    onEvent?.({ type: "thinking" });
+
+    const summaryMessages: ChatMessage[] = [
+      { role: "system", content: BASE_SYSTEM_PROMPT },
+      { role: "user", content: intent.summaryPrompt },
+    ];
+
+    const response = await client.chat(summaryMessages); // No tools!
+
+    onEvent?.({ type: "content", content: response.content });
+    onEvent?.({ type: "done" });
+
+    return {
+      content: response.content,
+      toolCalls: intent.toolResult
+        ? [{ tool: intent.toolName!, args: intent.toolArgs!, result: intent.toolResult }]
+        : [],
+    };
+  }
+
+  // Fallback: existing LLM-driven tool selection
+  const tools = selectTools(userMessage);
   const systemPrompt = buildSystemPrompt(contextSummary);
 
   const messages: ChatMessage[] = [
@@ -178,7 +554,64 @@ export async function* streamProcessMessage(
   abortSignal?: AbortSignal,
   contextSummary?: string
 ): AsyncGenerator<AgentEvent> {
-  const tools = getAllTools();
+  // Try intent router first
+  const intent = await detectAndExecuteIntent(userMessage, (event) => {
+    // Events are yielded by the caller, we collect them via callback
+    // But generators can't yield from callbacks, so we handle this differently
+  });
+
+  if (intent.handled) {
+    // Emit the tool events that happened during intent detection
+    if (intent.toolName) {
+      yield {
+        type: "tool_use",
+        tool: intent.toolName,
+        status: "start",
+        args: intent.toolArgs,
+      };
+
+      yield {
+        type: "tool_result",
+        tool: intent.toolName,
+        status: intent.toolResult?.success ? "complete" : "error",
+        result: intent.toolResult,
+      };
+    }
+
+    if (intent.summaryPrompt) {
+      if (abortSignal?.aborted) {
+        yield { type: "error", error: "Operation cancelled" };
+        return;
+      }
+
+      yield { type: "thinking" };
+
+      // Stream the LLM summary (no tools = streaming mode in ollama client)
+      const summaryMessages: ChatMessage[] = [
+        { role: "system", content: BASE_SYSTEM_PROMPT },
+        { role: "user", content: intent.summaryPrompt },
+      ];
+
+      for await (const event of client.streamChat(summaryMessages, undefined, abortSignal)) {
+        if (abortSignal?.aborted) {
+          yield { type: "error", error: "Operation cancelled" };
+          return;
+        }
+        if (event.type === "content" && event.content) {
+          yield { type: "content", content: event.content };
+        } else if (event.type === "error") {
+          yield { type: "error", error: event.error };
+          return;
+        }
+      }
+    }
+
+    yield { type: "done" };
+    return;
+  }
+
+  // Fallback: existing LLM-driven tool selection
+  const tools = selectTools(userMessage);
   const systemPrompt = buildSystemPrompt(contextSummary);
 
   const messages: ChatMessage[] = [

package/src/core/config.ts

@@ -29,7 +29,7 @@ const DEFAULT_CONFIG: Config = {
   ollama: {
     baseUrl: "http://localhost:11434",
     model: "mistral:latest",
-    contextLength: 8192,
+    contextLength: 4096,
     keepAlive: 1800, // 30 minutes
   },
   standards: {

package/src/core/llm/ollama.ts

@@ -1,5 +1,5 @@
 import { OllamaConfig } from "../config.js";
-import { Tool, ToolCall } from "../tools/types.js";
+import type { Tool, ToolCall } from "../tools/types.js";
 
 export interface ChatMessage {
   role: "system" | "user" | "assistant" | "tool";
@@ -30,6 +30,65 @@ interface OllamaChatResponse {
   done: boolean;
 }
 
+// Estimate token count for a string (rough: ~3 chars per token for mixed Korean/English)
+function estimateTokens(text: string): number {
+  if (!text) return 0;
+  return Math.ceil(text.length / 3);
+}
+
+// Estimate tokens for tool definitions sent to Ollama
+function estimateToolTokens(tools: Tool[]): number {
+  let total = 0;
+  for (const tool of tools) {
+    // name + description + JSON schema overhead
+    total += estimateTokens(tool.name) + estimateTokens(tool.description) + 20;
+    if (tool.parameters?.properties) {
+      for (const [key, prop] of Object.entries(tool.parameters.properties)) {
+        total += estimateTokens(key) + estimateTokens((prop as { description?: string }).description || "") + 10;
+      }
+    }
+  }
+  return total;
+}
+
+// Prune messages to fit within context window
+function pruneMessages(
+  messages: Array<{ role: string; content: string }>,
+  maxContextTokens: number,
+  toolTokens: number
+): Array<{ role: string; content: string }> {
+  if (messages.length <= 2) return messages;
+
+  const responseReserve = 1000; // reserve tokens for model response
+  const safetyBuffer = 200;
+  const budget = maxContextTokens - toolTokens - responseReserve - safetyBuffer;
+
+  // Always preserve: first message (system) and last message (user)
+  const systemMsg = messages[0];
+  const lastMsg = messages[messages.length - 1];
+  const history = messages.slice(1, -1);
+
+  let usedTokens = estimateTokens(systemMsg.content) + estimateTokens(lastMsg.content);
+
+  // If even system + last message exceeds budget, truncate system prompt
+  if (usedTokens > budget) {
+    const maxSystemChars = Math.max(200, (budget - estimateTokens(lastMsg.content)) * 3);
+    systemMsg.content = systemMsg.content.slice(0, maxSystemChars);
+    return [systemMsg, lastMsg];
+  }
+
+  // Add messages from newest to oldest
+  const kept: Array<{ role: string; content: string }> = [];
+  for (let i = history.length - 1; i >= 0; i--) {
+    const msgTokens = estimateTokens(history[i].content) + 4; // 4 tokens overhead per message
+    if (usedTokens + msgTokens > budget) break;
+    kept.unshift(history[i]);
+    usedTokens += msgTokens;
+  }
+
+  return [systemMsg, ...kept, lastMsg];
+}
+
 export class OllamaClient {
   private baseUrl: string;
   private model: string;
@@ -63,7 +122,11 @@ export class OllamaClient {
     messages: ChatMessage[],
     tools?: Tool[]
   ): Promise<ChatMessage> {
-    const ollamaMessages = this.convertMessages(messages);
+    let ollamaMessages = this.convertMessages(messages);
+
+    // Prune messages to fit within context window
+    const toolTokens = tools?.length ? estimateToolTokens(tools) : 0;
+    ollamaMessages = pruneMessages(ollamaMessages, this.contextLength, toolTokens);
 
     const body: Record<string, unknown> = {
       model: this.model,
@@ -107,7 +170,11 @@ export class OllamaClient {
     tools?: Tool[],
     abortSignal?: AbortSignal
   ): AsyncGenerator<StreamEvent> {
-    const ollamaMessages = this.convertMessages(messages);
+    let ollamaMessages = this.convertMessages(messages);
+
+    // Prune messages to fit within context window
+    const toolTokens = tools?.length ? estimateToolTokens(tools) : 0;
+    ollamaMessages = pruneMessages(ollamaMessages, this.contextLength, toolTokens);
 
     // Use non-streaming mode when tools are provided to avoid hallucination
     // (LLM often outputs fake results before tool calls in streaming mode)