activo 0.4.3 → 0.5.0

package/src/core/agent.ts

@@ -1,237 +0,0 @@
-import { OllamaClient, ChatMessage } from "./llm/ollama.js";
-import { Config } from "./config.js";
-import { getAllTools, selectTools, executeTool, ToolCall, ToolResult, Tool } from "./tools/index.js";
-
-export interface AgentEvent {
-  type: "thinking" | "content" | "tool_use" | "tool_result" | "done" | "error";
-  content?: string;
-  tool?: string;
-  status?: "start" | "complete" | "error";
-  args?: Record<string, unknown>;
-  result?: ToolResult;
-  error?: string;
-}
-
-export interface AgentResult {
-  content: string;
-  toolCalls: Array<{
-    tool: string;
-    args: Record<string, unknown>;
-    result: ToolResult;
-  }>;
-}
-
-const BASE_SYSTEM_PROMPT = `You are ACTIVO, a code quality analyzer. You MUST call tools to perform tasks.
-
-## RULES
-1. Call tool IMMEDIATELY when user requests an action
-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 {
-  if (!contextSummary) {
-    return BASE_SYSTEM_PROMPT;
-  }
-
-  return `${BASE_SYSTEM_PROMPT}
-
-## 이전 대화 컨텍스트
-
-${contextSummary}
-
----
-위 내용은 이전 세션에서의 대화 요약입니다. 필요시 참고하세요.`;
-}
-
-export async function processMessage(
-  userMessage: string,
-  history: ChatMessage[],
-  client: OllamaClient,
-  config: Config,
-  onEvent?: (event: AgentEvent) => void,
-  contextSummary?: string
-): Promise<AgentResult> {
-  const tools = selectTools(userMessage);
-  const systemPrompt = buildSystemPrompt(contextSummary);
-
-  const messages: ChatMessage[] = [
-    { role: "system", content: systemPrompt },
-    ...history,
-    { role: "user", content: userMessage },
-  ];
-
-  const toolCallResults: AgentResult["toolCalls"] = [];
-  let finalContent = "";
-  let iterations = 0;
-  const maxIterations = 10;
-
-  while (iterations < maxIterations) {
-    iterations++;
-
-    onEvent?.({ type: "thinking" });
-
-    const response = await client.chat(messages, tools as Tool[]);
-    messages.push(response);
-
-    // If no tool calls, we're done
-    if (!response.toolCalls?.length) {
-      finalContent = response.content;
-      break;
-    }
-
-    // Process tool calls
-    for (const toolCall of response.toolCalls) {
-      onEvent?.({
-        type: "tool_use",
-        tool: toolCall.name,
-        status: "start",
-        args: toolCall.arguments,
-      });
-
-      const result = await executeTool(toolCall);
-
-      onEvent?.({
-        type: "tool_result",
-        tool: toolCall.name,
-        status: result.success ? "complete" : "error",
-        result,
-      });
-
-      toolCallResults.push({
-        tool: toolCall.name,
-        args: toolCall.arguments,
-        result,
-      });
-
-      // Add tool result to messages
-      messages.push({
-        role: "tool",
-        content: result.success ? result.content : `Error: ${result.error}`,
-        toolCallId: toolCall.id,
-      });
-    }
-
-    // Continue the conversation with tool results
-    onEvent?.({ type: "content", content: response.content });
-  }
-
-  if (iterations >= maxIterations) {
-    onEvent?.({ type: "error", error: "Maximum iterations reached" });
-  }
-
-  onEvent?.({ type: "done" });
-
-  return {
-    content: finalContent,
-    toolCalls: toolCallResults,
-  };
-}
-
-export async function* streamProcessMessage(
-  userMessage: string,
-  history: ChatMessage[],
-  client: OllamaClient,
-  config: Config,
-  abortSignal?: AbortSignal,
-  contextSummary?: string
-): AsyncGenerator<AgentEvent> {
-  const tools = selectTools(userMessage);
-  const systemPrompt = buildSystemPrompt(contextSummary);
-
-  const messages: ChatMessage[] = [
-    { role: "system", content: systemPrompt },
-    ...history,
-    { role: "user", content: userMessage },
-  ];
-
-  let iterations = 0;
-  const maxIterations = 10;
-
-  while (iterations < maxIterations) {
-    // Check if aborted
-    if (abortSignal?.aborted) {
-      yield { type: "error", error: "Operation cancelled" };
-      return;
-    }
-
-    iterations++;
-
-    yield { type: "thinking" };
-
-    let fullContent = "";
-    const pendingToolCalls: ToolCall[] = [];
-
-    // Collect all events first (non-streaming mode for tools)
-    for await (const event of client.streamChat(messages, tools as Tool[], abortSignal)) {
-      if (abortSignal?.aborted) {
-        yield { type: "error", error: "Operation cancelled" };
-        return;
-      }
-      if (event.type === "content" && event.content) {
-        fullContent += event.content;
-        // Don't yield content yet - wait to see if there are tool calls
-      } else if (event.type === "tool_call" && event.toolCall) {
-        pendingToolCalls.push(event.toolCall);
-      } else if (event.type === "error") {
-        yield { type: "error", error: event.error };
-        return;
-      }
-    }
-
-    // Only yield content if NO tool calls (avoid hallucinated pre-tool text)
-    if (pendingToolCalls.length === 0 && fullContent) {
-      yield { type: "content", content: fullContent };
-    } else if (pendingToolCalls.length > 0) {
-      // Clear content when tool calls exist
-      fullContent = "";
-    }
-
-    messages.push({ role: "assistant", content: fullContent, toolCalls: pendingToolCalls.length > 0 ? pendingToolCalls : undefined });
-
-    // If no tool calls, we're done
-    if (pendingToolCalls.length === 0) {
-      break;
-    }
-
-    // Process tool calls
-    for (const toolCall of pendingToolCalls) {
-      // Check if aborted before each tool call
-      if (abortSignal?.aborted) {
-        yield { type: "error", error: "Operation cancelled" };
-        return;
-      }
-
-      yield {
-        type: "tool_use",
-        tool: toolCall.name,
-        status: "start",
-        args: toolCall.arguments,
-      };
-
-      const result = await executeTool(toolCall);
-
-      // Check if aborted after tool execution
-      if (abortSignal?.aborted) {
-        yield { type: "error", error: "Operation cancelled" };
-        return;
-      }
-
-      yield {
-        type: "tool_result",
-        tool: toolCall.name,
-        status: result.success ? "complete" : "error",
-        result,
-      };
-
-      messages.push({
-        role: "tool",
-        content: result.success ? result.content : `Error: ${result.error}`,
-        toolCallId: toolCall.id,
-      });
-    }
-  }
-
-  yield { type: "done" };
-}

package/src/core/commands.ts

@@ -1,118 +0,0 @@
-import { Config, loadConfig, saveConfig } from "./config.js";
-
-export interface SlashCommandResult {
-  output?: string;
-  exit?: boolean;
-  clear?: boolean;
-  changeModel?: string;
-  showHelp?: boolean;
-}
-
-type CommandHandler = (args: string[], config: Config) => SlashCommandResult;
-
-const HELP_MESSAGE = `
-ACTIVO - AI 코드 품질 분석 도구
-
-[슬래시 커맨드]
-  /help          이 도움말 표시
-  /exit, /quit   종료
-  /clear         채팅 기록 삭제
-  /model <name>  모델 변경 (예: /model qwen2.5:7b)
-  /info          현재 설정 정보 표시
-
-[단축키]
-  Enter          메시지 전송
-  ESC            진행 중 작업 취소
-  Ctrl+C x2      종료
-
-[사용 예시]
-  "src 폴더 구조 보여줘"
-  "package.json 분석해줘"
-  "코드 품질 검사해줘"
-  "PDF를 마크다운으로 변환해줘"
-`.trim();
-
-const commandHandlers: Record<string, CommandHandler> = {
-  help: () => ({
-    output: HELP_MESSAGE,
-    showHelp: true,
-  }),
-
-  exit: () => ({
-    exit: true,
-    output: "Goodbye!",
-  }),
-
-  quit: () => ({
-    exit: true,
-    output: "Goodbye!",
-  }),
-
-  clear: () => ({
-    clear: true,
-    output: "채팅 기록이 삭제되었습니다.",
-  }),
-
-  model: (args, config) => {
-    if (args.length === 0) {
-      return {
-        output: `현재 모델: ${config.ollama.model}\n\n사용법: /model <model_name>\n예시: /model qwen2.5:7b`,
-      };
-    }
-
-    const newModel = args[0];
-    config.ollama.model = newModel;
-    saveConfig(config);
-
-    return {
-      changeModel: newModel,
-      output: `모델이 "${newModel}"로 변경되었습니다.`,
-    };
-  },
-
-  info: (args, config) => {
-    const info = `
-[ACTIVO 정보]
-  버전: 0.2.1
-
-[Ollama 설정]
-  URL: ${config.ollama.baseUrl}
-  모델: ${config.ollama.model}
-  컨텍스트: ${config.ollama.contextLength}
-
-[표준 디렉토리]
-  ${config.standards.directory}
-`.trim();
-
-    return { output: info };
-  },
-};
-
-export function handleSlashCommand(
-  input: string,
-  config: Config
-): SlashCommandResult | null {
-  // "/" 로 시작하지 않으면 null 반환
-  if (!input.startsWith("/")) {
-    return null;
-  }
-
-  // 파싱: "/" 제거 후 공백으로 분할
-  const trimmed = input.slice(1).trim();
-  const [command, ...args] = trimmed.split(/\s+/);
-
-  if (!command) {
-    return { output: "명령어를 입력하세요. /help 로 도움말을 확인하세요." };
-  }
-
-  const handler = commandHandlers[command.toLowerCase()];
-  if (handler) {
-    return handler(args, config);
-  }
-
-  return { output: `알 수 없는 명령어: /${command}\n/help 로 사용 가능한 명령어를 확인하세요.` };
-}
-
-export function getAvailableCommands(): string[] {
-  return Object.keys(commandHandlers);
-}

package/src/core/config.ts

@@ -1,98 +0,0 @@
-import fs from "fs";
-import path from "path";
-import os from "os";
-
-export interface OllamaConfig {
-  baseUrl: string;
-  model: string;
-  contextLength: number;
-  keepAlive: number;
-}
-
-export interface Config {
-  ollama: OllamaConfig;
-  standards: {
-    directory: string;
-  };
-  mcp: {
-    servers: Record<string, MCPServerConfig>;
-  };
-}
-
-export interface MCPServerConfig {
-  command: string;
-  args?: string[];
-  env?: Record<string, string>;
-}
-
-const DEFAULT_CONFIG: Config = {
-  ollama: {
-    baseUrl: "http://localhost:11434",
-    model: "mistral:latest",
-    contextLength: 4096,
-    keepAlive: 1800, // 30 minutes
-  },
-  standards: {
-    directory: ".activo/standards",
-  },
-  mcp: {
-    servers: {},
-  },
-};
-
-function getConfigPath(): string {
-  return path.join(os.homedir(), ".activo", "config.json");
-}
-
-export function loadConfig(): Config {
-  const configPath = getConfigPath();
-
-  if (fs.existsSync(configPath)) {
-    try {
-      const data = fs.readFileSync(configPath, "utf-8");
-      const loaded = JSON.parse(data);
-      return {
-        ollama: { ...DEFAULT_CONFIG.ollama, ...loaded.ollama },
-        standards: { ...DEFAULT_CONFIG.standards, ...loaded.standards },
-        mcp: { ...DEFAULT_CONFIG.mcp, ...loaded.mcp },
-      };
-    } catch {
-      return DEFAULT_CONFIG;
-    }
-  }
-
-  return DEFAULT_CONFIG;
-}
-
-export function saveConfig(config: Config): void {
-  const configPath = getConfigPath();
-  const configDir = path.dirname(configPath);
-
-  if (!fs.existsSync(configDir)) {
-    fs.mkdirSync(configDir, { recursive: true });
-  }
-
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-}
-
-export function getProjectConfig(): Config {
-  const projectConfigPath = path.join(process.cwd(), ".activo", "config.json");
-
-  if (fs.existsSync(projectConfigPath)) {
-    try {
-      const data = fs.readFileSync(projectConfigPath, "utf-8");
-      const projectConfig = JSON.parse(data);
-      const globalConfig = loadConfig();
-
-      return {
-        ollama: { ...globalConfig.ollama, ...projectConfig.ollama },
-        standards: { ...globalConfig.standards, ...projectConfig.standards },
-        mcp: { ...globalConfig.mcp, ...projectConfig.mcp },
-      };
-    } catch {
-      return loadConfig();
-    }
-  }
-
-  return loadConfig();
-}

package/src/core/conversation.ts

@@ -1,235 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { ChatMessage, OllamaClient } from "./llm/ollama.js";
-
-// Conversation storage directory
-const CONVERSATION_DIR = ".activo/conversations";
-
-// Session data interface
-interface SessionData {
-  id: string;
-  startedAt: string;
-  updatedAt: string;
-  messages: ChatMessage[];
-  summary?: string;
-}
-
-// Get conversation directory path
-function getConversationDir(): string {
-  return path.resolve(process.cwd(), CONVERSATION_DIR);
-}
-
-// Ensure conversation directory exists
-function ensureConversationDir(): void {
-  const dir = getConversationDir();
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-}
-
-// Generate session ID
-export function generateSessionId(): string {
-  return `session_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-}
-
-// Get session file path
-function getSessionPath(sessionId: string): string {
-  return path.join(getConversationDir(), `${sessionId}.json`);
-}
-
-// Get latest session file
-function getLatestSessionPath(): string | null {
-  const dir = getConversationDir();
-  if (!fs.existsSync(dir)) {
-    return null;
-  }
-
-  const files = fs.readdirSync(dir)
-    .filter(f => f.startsWith("session_") && f.endsWith(".json"))
-    .sort()
-    .reverse();
-
-  if (files.length === 0) {
-    return null;
-  }
-
-  return path.join(dir, files[0]);
-}
-
-// Load session data
-export function loadSession(sessionId: string): SessionData | null {
-  const sessionPath = getSessionPath(sessionId);
-  if (!fs.existsSync(sessionPath)) {
-    return null;
-  }
-
-  try {
-    return JSON.parse(fs.readFileSync(sessionPath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-
-// Load latest session
-export function loadLatestSession(): SessionData | null {
-  const latestPath = getLatestSessionPath();
-  if (!latestPath) {
-    return null;
-  }
-
-  try {
-    return JSON.parse(fs.readFileSync(latestPath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-
-// Save session data
-export function saveSession(session: SessionData): void {
-  ensureConversationDir();
-  session.updatedAt = new Date().toISOString();
-  fs.writeFileSync(getSessionPath(session.id), JSON.stringify(session, null, 2));
-}
-
-// Create new session
-export function createSession(): SessionData {
-  return {
-    id: generateSessionId(),
-    startedAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-    messages: [],
-  };
-}
-
-// Add message to session
-export function addMessageToSession(session: SessionData, message: ChatMessage): void {
-  session.messages.push(message);
-  saveSession(session);
-}
-
-// Summarize old messages using LLM
-async function summarizeMessages(
-  messages: ChatMessage[],
-  client: OllamaClient
-): Promise<string> {
-  if (messages.length === 0) {
-    return "";
-  }
-
-  // Format messages for summarization
-  const conversationText = messages
-    .filter(m => m.role !== "system" && m.role !== "tool")
-    .map(m => {
-      if (m.role === "user") {
-        return `사용자: ${m.content}`;
-      } else if (m.role === "assistant") {
-        const toolInfo = m.toolCalls?.length
-          ? ` [도구 호출: ${m.toolCalls.map(t => t.name).join(", ")}]`
-          : "";
-        return `어시스턴트: ${m.content.slice(0, 200)}${m.content.length > 200 ? "..." : ""}${toolInfo}`;
-      }
-      return "";
-    })
-    .filter(s => s)
-    .join("\n");
-
-  const summaryPrompt = `다음 대화를 3-5개의 핵심 포인트로 요약해주세요. 한국어로 작성하고, 각 포인트는 한 줄로 작성하세요.
-
-대화:
-${conversationText}
-
-요약 (핵심 포인트만):`;
-
-  try {
-    const response = await client.chat([
-      { role: "user", content: summaryPrompt }
-    ]);
-    return response.content.trim();
-  } catch (error) {
-    // Fallback: simple extraction
-    const userMessages = messages
-      .filter(m => m.role === "user")
-      .map(m => m.content.slice(0, 50))
-      .slice(-3);
-    return `이전 요청: ${userMessages.join(", ")}`;
-  }
-}
-
-// Get context for new session (hybrid approach)
-export async function getSessionContext(
-  client: OllamaClient,
-  recentCount: number = 5
-): Promise<{ summary: string; recentMessages: ChatMessage[] }> {
-  const latestSession = loadLatestSession();
-
-  if (!latestSession || latestSession.messages.length === 0) {
-    return { summary: "", recentMessages: [] };
-  }
-
-  const allMessages = latestSession.messages;
-
-  // Filter out system messages for context
-  const contextMessages = allMessages.filter(m => m.role !== "system");
-
-  if (contextMessages.length <= recentCount) {
-    // Not enough messages to summarize, return all as recent
-    return {
-      summary: latestSession.summary || "",
-      recentMessages: contextMessages
-    };
-  }
-
-  // Split: old messages for summary, recent messages to keep
-  const oldMessages = contextMessages.slice(0, -recentCount);
-  const recentMessages = contextMessages.slice(-recentCount);
-
-  // Generate or use existing summary
-  let summary = latestSession.summary || "";
-
-  if (oldMessages.length > 0 && !summary) {
-    summary = await summarizeMessages(oldMessages, client);
-    // Save summary back to session
-    latestSession.summary = summary;
-    saveSession(latestSession);
-  }
-
-  return { summary, recentMessages };
-}
-
-// Build context string for system prompt
-export function buildContextPrompt(summary: string): string {
-  if (!summary) {
-    return "";
-  }
-
-  return `
-## 이전 대화 컨텍스트
-
-${summary}
-
----
-위 내용은 이전 세션에서의 대화 요약입니다. 필요시 참고하세요.
-`;
-}
-
-// Clean old sessions (keep only last N)
-export function cleanOldSessions(keepCount: number = 10): void {
-  const dir = getConversationDir();
-  if (!fs.existsSync(dir)) {
-    return;
-  }
-
-  const files = fs.readdirSync(dir)
-    .filter(f => f.startsWith("session_") && f.endsWith(".json"))
-    .sort()
-    .reverse();
-
-  // Delete old sessions beyond keepCount
-  for (let i = keepCount; i < files.length; i++) {
-    try {
-      fs.unlinkSync(path.join(dir, files[i]));
-    } catch {
-      // Ignore deletion errors
-    }
-  }
-}