activo 0.2.0

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "activo",
+  "version": "0.2.0",
+  "description": "AI-powered code quality analyzer with React Ink TUI, Tool Calling, and MCP support",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mhb8436/activo.git"
+  },
+  "homepage": "https://github.com/mhb8436/activo",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "bin": {
+    "activo": "dist/cli/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli/index.ts",
+    "start": "node dist/cli/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "lint": "eslint src/",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "code-quality",
+    "cli",
+    "ollama",
+    "ai",
+    "mcp",
+    "tool-calling",
+    "react-ink"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.52.0",
+    "@modelcontextprotocol/sdk": "^1.24.0",
+    "chalk": "^5.4.1",
+    "commander": "^14.0.0",
+    "date-fns": "^4.1.0",
+    "glob": "^11.0.0",
+    "gradient-string": "^3.0.0",
+    "ink": "^6.1.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "pdf-parse": "^1.1.1",
+    "react": "^19.1.0",
+    "uuid": "^10.0.0"
+  },
+  "devDependencies": {
+    "@types/gradient-string": "^1.1.6",
+    "@types/node": "^22.10.0",
+    "@types/pdf-parse": "^1.1.4",
+    "@types/react": "^19.1.0",
+    "@types/uuid": "^10.0.0",
+    "tsx": "^4.20.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.2.0"
+  }
+}

package/src/cli/banner.ts

@@ -0,0 +1,34 @@
+import gradient from "gradient-string";
+
+const ACTIVO_ASCII = `
+    _    ____ _____ _____     _____
+   / \\  / ___|_   _|_ _\\ \\   / / _ \\
+  / _ \\| |     | |  | | \\ \\ / / | | |
+ / ___ \\ |___  | |  | |  \\ V /| |_| |
+/_/   \\_\\____| |_| |___|  \\_/  \\___/
+`;
+
+const SUBTITLE = "AI-Powered Code Quality Analyzer";
+const VERSION = "v0.2.0";
+
+export function showBanner(): void {
+  const activoGradient = gradient(["#00d4ff", "#7b2ff7", "#f107a3"]);
+
+  console.log(activoGradient.multiline(ACTIVO_ASCII));
+  console.log();
+  console.log(`  ${gradient(["#7b2ff7", "#00d4ff"])(SUBTITLE)}  ${VERSION}`);
+  console.log();
+  console.log("  Type your request in natural language.");
+  console.log("  Examples:");
+  console.log("    • 이 프로젝트의 코드 품질을 분석해줘");
+  console.log("    • PDF 파일을 마크다운 규칙으로 변환해줘");
+  console.log("    • src 폴더의 명명규칙 위반을 찾아줘");
+  console.log();
+  console.log("  Press Ctrl+C twice to exit");
+  console.log("─".repeat(50));
+  console.log();
+}
+
+export function getShortBanner(): string {
+  return gradient(["#00d4ff", "#7b2ff7"])("ACTIVO") + " - Code Quality Analyzer";
+}

package/src/cli/headless.ts

@@ -0,0 +1,37 @@
+import { OllamaClient } from "../core/llm/ollama.js";
+import { processMessage } from "../core/agent.js";
+import { Config } from "../core/config.js";
+import chalk from "chalk";
+
+export async function runHeadless(prompt: string | undefined, config: Config): Promise<void> {
+  if (!prompt) {
+    console.error(chalk.red("Error: Prompt is required in headless mode"));
+    console.error(chalk.yellow("Usage: activo -p \"your prompt here\""));
+    process.exit(1);
+  }
+
+  const client = new OllamaClient(config.ollama);
+
+  // Check connection
+  const isConnected = await client.isConnected();
+  if (!isConnected) {
+    console.error(chalk.red("Error: Cannot connect to Ollama"));
+    console.error(chalk.yellow(`Make sure Ollama is running at ${config.ollama.baseUrl}`));
+    process.exit(1);
+  }
+
+  try {
+    const result = await processMessage(prompt, [], client, config, (event) => {
+      if (event.type === "tool_use") {
+        console.error(chalk.dim(`[Tool] ${event.tool}: ${event.status}`));
+      } else if (event.type === "thinking") {
+        // Skip thinking in headless mode
+      }
+    });
+
+    console.log(result.content);
+  } catch (error) {
+    console.error(chalk.red(`Error: ${error}`));
+    process.exit(1);
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import { render } from "ink";
+import React from "react";
+import { App } from "../ui/App.js";
+import { showBanner } from "./banner.js";
+import { loadConfig } from "../core/config.js";
+
+const program = new Command();
+
+program
+  .name("activo")
+  .description("AI-powered code quality analyzer with Tool Calling and MCP support")
+  .version("0.2.0", "-v, --version", "Display version number");
+
+program
+  .option("-p, --print", "Non-interactive mode (print and exit)")
+  .option("--headless", "Headless mode for CI/CD")
+  .option("--resume", "Resume from last session")
+  .option("--model <model>", "Specify Ollama model")
+  .argument("[prompt]", "Initial prompt")
+  .action(async (prompt, options) => {
+    // Show ASCII banner
+    showBanner();
+
+    // Load config
+    const config = loadConfig();
+
+    if (options.model) {
+      config.ollama.model = options.model;
+    }
+
+    // Headless/print mode
+    if (options.print || options.headless) {
+      const { runHeadless } = await import("./headless.js");
+      await runHeadless(prompt, config);
+      return;
+    }
+
+    // Interactive TUI mode
+    const { waitUntilExit } = render(
+      React.createElement(App, {
+        initialPrompt: prompt,
+        config,
+        resume: options.resume,
+      })
+    );
+
+    await waitUntilExit();
+  });
+
+program.parse();

package/src/core/agent.ts

@@ -0,0 +1,235 @@
+import { OllamaClient, ChatMessage } from "./llm/ollama.js";
+import { Config } from "./config.js";
+import { getAllTools, 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 SYSTEM_PROMPT = `You are ACTIVO, an AI-powered code quality analyzer.
+
+You help developers:
+1. Analyze code quality and find issues
+2. Import development standards from PDFs
+3. Check code against standards
+4. Navigate and understand codebases
+
+You have access to these tools:
+- read_file: Read file contents
+- write_file: Write content to files
+- list_directory: List directory contents
+- grep_search: Search for patterns in files
+- glob_search: Find files by pattern
+- run_command: Execute shell commands
+- import_pdf_standards: Convert PDF to markdown rules
+- list_standards: List loaded standards
+- check_code_quality: Check code against standards
+
+When users ask in natural language, use the appropriate tools to help them.
+Examples:
+- "이 프로젝트 분석해줘" → Use list_directory, read_file to explore
+- "PDF 규칙으로 변환해줘" → Use import_pdf_standards
+- "코드 품질 검사해줘" → Use check_code_quality
+- "UserService 찾아줘" → Use grep_search or glob_search
+
+Always explain what you're doing and provide helpful insights.
+Respond in the same language as the user's input.`;
+
+export async function processMessage(
+  userMessage: string,
+  history: ChatMessage[],
+  client: OllamaClient,
+  config: Config,
+  onEvent?: (event: AgentEvent) => void
+): Promise<AgentResult> {
+  const tools = getAllTools();
+  const toolDefinitions = tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    parameters: t.parameters,
+  }));
+
+  const messages: ChatMessage[] = [
+    { role: "system", content: SYSTEM_PROMPT },
+    ...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
+): AsyncGenerator<AgentEvent> {
+  const tools = getAllTools();
+
+  const messages: ChatMessage[] = [
+    { role: "system", content: SYSTEM_PROMPT },
+    ...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[] = [];
+
+    for await (const event of client.streamChat(messages, tools as Tool[], abortSignal)) {
+      // Check if aborted during streaming
+      if (abortSignal?.aborted) {
+        yield { type: "error", error: "Operation cancelled" };
+        return;
+      }
+      if (event.type === "content" && event.content) {
+        fullContent += event.content;
+        yield { type: "content", content: event.content };
+      } else if (event.type === "tool_call" && event.toolCall) {
+        pendingToolCalls.push(event.toolCall);
+      } else if (event.type === "error") {
+        yield { type: "error", error: event.error };
+        return;
+      }
+    }
+
+    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/config.ts

@@ -0,0 +1,98 @@
+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: 8192,
+    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();
+}