activo 0.2.0

package/src/core/tools/standards.ts

@@ -0,0 +1,246 @@
+import fs from "fs";
+import path from "path";
+import pdfParse from "pdf-parse";
+import { Tool, ToolResult } from "./types.js";
+import { OllamaClient } from "../llm/ollama.js";
+import { loadConfig } from "../config.js";
+
+// Import PDF Tool
+export const importPdfTool: Tool = {
+  name: "import_pdf_standards",
+  description: "Import development standards from a PDF file and convert to markdown rules.",
+  parameters: {
+    type: "object",
+    required: ["pdfPath"],
+    properties: {
+      pdfPath: {
+        type: "string",
+        description: "Path to the PDF file",
+      },
+      outputDir: {
+        type: "string",
+        description: "Output directory (default: .activo/standards)",
+      },
+    },
+  },
+  handler: async (args): Promise<ToolResult> => {
+    try {
+      const pdfPath = path.resolve(args.pdfPath as string);
+      const outputDir = path.resolve((args.outputDir as string) || ".activo/standards");
+
+      if (!fs.existsSync(pdfPath)) {
+        return { success: false, content: "", error: `PDF not found: ${pdfPath}` };
+      }
+
+      // Parse PDF
+      const dataBuffer = fs.readFileSync(pdfPath);
+      const data = await pdfParse(dataBuffer);
+
+      // Create output directory
+      if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+      }
+
+      // Split into chunks (simple approach: by paragraphs)
+      const chunks = splitIntoChunks(data.text, 3000);
+      const filename = path.basename(pdfPath, ".pdf");
+      const extractionDate = new Date().toISOString().split("T")[0];
+
+      // Save chunks as markdown
+      const results: string[] = [];
+      for (let i = 0; i < chunks.length; i++) {
+        const chunkFilename = `${String(i + 1).padStart(2, "0")}_${sanitize(filename)}.md`;
+        const chunkPath = path.join(outputDir, chunkFilename);
+
+        let md = `# ${filename} - Part ${i + 1}\n\n`;
+        md += `> Source: ${path.basename(pdfPath)}\n`;
+        md += `> Extracted: ${extractionDate}\n`;
+        md += `> Pages: ${data.numpages}\n\n`;
+        md += `---\n\n`;
+        md += chunks[i];
+        md += `\n\n---\n`;
+        md += `[Edit this file to add structured rules]\n`;
+
+        fs.writeFileSync(chunkPath, md);
+        results.push(chunkFilename);
+      }
+
+      // Create index
+      const indexPath = path.join(outputDir, "_index.md");
+      let indexMd = `# Development Standards Index\n\n`;
+      indexMd += `> Source: ${path.basename(pdfPath)}\n`;
+      indexMd += `> Extracted: ${extractionDate}\n`;
+      indexMd += `> Files: ${results.length}\n\n`;
+      indexMd += `## Files\n\n`;
+      for (const r of results) {
+        indexMd += `- [${r}](./${r})\n`;
+      }
+      fs.writeFileSync(indexPath, indexMd);
+
+      return {
+        success: true,
+        content: `Imported ${results.length} files to ${outputDir}\n\nFiles:\n${results.join("\n")}\n\nNext: Edit the files to add structured rules with format:\n## RULE-001: Title\n- 심각도: error|warning|info\n- 규칙: description`,
+      };
+    } catch (error) {
+      return { success: false, content: "", error: String(error) };
+    }
+  },
+};
+
+// List Standards Tool
+export const listStandardsTool: Tool = {
+  name: "list_standards",
+  description: "List all loaded development standards and rules.",
+  parameters: {
+    type: "object",
+    properties: {
+      directory: {
+        type: "string",
+        description: "Standards directory (default: .activo/standards)",
+      },
+    },
+  },
+  handler: async (args): Promise<ToolResult> => {
+    try {
+      const dir = path.resolve((args.directory as string) || ".activo/standards");
+
+      if (!fs.existsSync(dir)) {
+        return { success: true, content: "No standards directory found. Import a PDF first." };
+      }
+
+      const files = fs.readdirSync(dir).filter((f) => f.endsWith(".md") && f !== "_index.md");
+      if (files.length === 0) {
+        return { success: true, content: "No standard files found." };
+      }
+
+      let totalRules = 0;
+      const results: string[] = [];
+
+      for (const file of files) {
+        const content = fs.readFileSync(path.join(dir, file), "utf-8");
+        const rules = content.match(/^## [A-Z]+-\d+/gm) || [];
+        totalRules += rules.length;
+        results.push(`📄 ${file}: ${rules.length} rules`);
+      }
+
+      return {
+        success: true,
+        content: `Standards Directory: ${dir}\n\n${results.join("\n")}\n\nTotal: ${files.length} files, ${totalRules} rules`,
+      };
+    } catch (error) {
+      return { success: false, content: "", error: String(error) };
+    }
+  },
+};
+
+// Check Code Quality Tool
+export const checkQualityTool: Tool = {
+  name: "check_code_quality",
+  description: "Check code against loaded development standards.",
+  parameters: {
+    type: "object",
+    required: ["filepath"],
+    properties: {
+      filepath: {
+        type: "string",
+        description: "File or directory to check",
+      },
+      standardsDir: {
+        type: "string",
+        description: "Standards directory (default: .activo/standards)",
+      },
+    },
+  },
+  handler: async (args): Promise<ToolResult> => {
+    try {
+      const filepath = path.resolve(args.filepath as string);
+      const standardsDir = path.resolve((args.standardsDir as string) || ".activo/standards");
+
+      if (!fs.existsSync(filepath)) {
+        return { success: false, content: "", error: `Path not found: ${filepath}` };
+      }
+
+      // Load standards
+      let standards = "";
+      if (fs.existsSync(standardsDir)) {
+        const files = fs.readdirSync(standardsDir).filter((f) => f.endsWith(".md") && f !== "_index.md");
+        for (const file of files) {
+          standards += fs.readFileSync(path.join(standardsDir, file), "utf-8") + "\n\n";
+        }
+      }
+
+      // Get code
+      let code = "";
+      const stat = fs.statSync(filepath);
+      if (stat.isFile()) {
+        code = fs.readFileSync(filepath, "utf-8");
+      } else {
+        return { success: false, content: "", error: "Directory check not yet supported. Specify a file." };
+      }
+
+      // Build analysis prompt
+      const prompt = buildAnalysisPrompt(code, filepath, standards);
+
+      // Call Ollama
+      const config = loadConfig();
+      const client = new OllamaClient(config.ollama);
+
+      const response = await client.chat([{ role: "user", content: prompt }]);
+
+      return { success: true, content: response.content };
+    } catch (error) {
+      return { success: false, content: "", error: String(error) };
+    }
+  },
+};
+
+// Helper functions
+function splitIntoChunks(text: string, maxSize: number): string[] {
+  const chunks: string[] = [];
+  const paragraphs = text.split(/\n\n+/);
+  let current = "";
+
+  for (const para of paragraphs) {
+    if (current.length + para.length > maxSize && current.length > 0) {
+      chunks.push(current.trim());
+      current = "";
+    }
+    current += para + "\n\n";
+  }
+
+  if (current.trim()) {
+    chunks.push(current.trim());
+  }
+
+  return chunks.length > 0 ? chunks : [text];
+}
+
+function sanitize(name: string): string {
+  return name.replace(/[^a-zA-Z0-9가-힣\s-]/g, "").replace(/\s+/g, "_").slice(0, 50);
+}
+
+function buildAnalysisPrompt(code: string, filepath: string, standards: string): string {
+  const ext = path.extname(filepath);
+  const lang = { ".ts": "typescript", ".js": "javascript", ".java": "java", ".py": "python" }[ext] || "text";
+
+  let prompt = `당신은 코드 품질 전문가입니다. 아래 코드를 분석하세요.\n\n`;
+
+  if (standards) {
+    prompt += `[개발 표준 규칙]\n${standards.slice(0, 4000)}\n\n`;
+  }
+
+  prompt += `[분석 대상 코드]\n파일: ${filepath}\n\`\`\`${lang}\n${code.slice(0, 8000)}\n\`\`\`\n\n`;
+  prompt += `[점검 요청]\n`;
+  prompt += `1. 규칙 위반 사항 (있다면)\n`;
+  prompt += `2. 개선 제안\n`;
+  prompt += `3. 전반적인 코드 품질 평가\n`;
+
+  return prompt;
+}
+
+// All standards tools
+export const standardsTools: Tool[] = [
+  importPdfTool,
+  listStandardsTool,
+  checkQualityTool,
+];

package/src/core/tools/types.ts

@@ -0,0 +1,37 @@
+export interface Tool {
+  name: string;
+  description: string;
+  parameters: {
+    type: "object";
+    required?: string[];
+    properties: Record<string, ToolParameter>;
+  };
+  handler: (args: Record<string, unknown>) => Promise<ToolResult>;
+}
+
+export interface ToolParameter {
+  type: string;
+  description: string;
+  enum?: string[];
+  default?: unknown;
+}
+
+export interface ToolCall {
+  id: string;
+  name: string;
+  arguments: Record<string, unknown>;
+}
+
+export interface ToolResult {
+  success: boolean;
+  content: string;
+  error?: string;
+}
+
+export interface ToolEvent {
+  type: "tool_use";
+  tool: string;
+  status: "start" | "complete" | "error";
+  args?: Record<string, unknown>;
+  result?: ToolResult;
+}

package/src/ui/App.tsx

@@ -0,0 +1,238 @@
+import React, { useState, useEffect, useCallback, useRef } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import { Config } from "../core/config.js";
+import { OllamaClient, ChatMessage } from "../core/llm/ollama.js";
+import { streamProcessMessage, AgentEvent } from "../core/agent.js";
+import { InputBox } from "./components/InputBox.js";
+import { MessageList } from "./components/MessageList.js";
+import { StatusBar } from "./components/StatusBar.js";
+import { ToolStatus } from "./components/ToolStatus.js";
+
+interface AppProps {
+  initialPrompt?: string;
+  config: Config;
+  resume?: boolean;
+}
+
+interface Message {
+  role: "user" | "assistant";
+  content: string;
+  toolCalls?: Array<{
+    tool: string;
+    status: "running" | "complete" | "error";
+    result?: string;
+  }>;
+}
+
+export function App({ initialPrompt, config, resume }: AppProps): React.ReactElement {
+  const { exit } = useApp();
+  const [messages, setMessages] = useState<Message[]>([]);
+  const [input, setInput] = useState("");
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [currentTool, setCurrentTool] = useState<string | null>(null);
+  const [toolStatus, setToolStatus] = useState<"running" | "complete" | "error" | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [client] = useState(() => new OllamaClient(config.ollama));
+  const [exitPending, setExitPending] = useState(false);
+  const [cancelled, setCancelled] = useState(false);
+  const abortControllerRef = useRef<AbortController | null>(null);
+
+  // Handle Ctrl+C and ESC
+  useInput((inputChar, key) => {
+    // ESC key to cancel current operation
+    if (key.escape && isProcessing) {
+      if (abortControllerRef.current) {
+        abortControllerRef.current.abort();
+        setCancelled(true);
+        setIsProcessing(false);
+        setCurrentTool(null);
+        setToolStatus(null);
+        setError("Operation cancelled by user (ESC)");
+      }
+      return;
+    }
+
+    // Ctrl+C to exit
+    if (key.ctrl && inputChar === "c") {
+      if (isProcessing && abortControllerRef.current) {
+        abortControllerRef.current.abort();
+        setCancelled(true);
+        setIsProcessing(false);
+        setCurrentTool(null);
+        setToolStatus(null);
+        return;
+      }
+      if (exitPending) {
+        exit();
+      } else {
+        setExitPending(true);
+        setTimeout(() => setExitPending(false), 1000);
+      }
+    }
+  });
+
+  // Check Ollama connection on mount
+  useEffect(() => {
+    const checkConnection = async () => {
+      const connected = await client.isConnected();
+      if (!connected) {
+        setError(`Cannot connect to Ollama at ${config.ollama.baseUrl}`);
+      }
+    };
+    checkConnection();
+  }, [client, config.ollama.baseUrl]);
+
+  // Process initial prompt
+  useEffect(() => {
+    if (initialPrompt) {
+      handleSubmit(initialPrompt);
+    }
+  }, [initialPrompt]);
+
+  const handleSubmit = useCallback(async (text: string) => {
+    if (!text.trim() || isProcessing) return;
+
+    setInput("");
+    setIsProcessing(true);
+    setError(null);
+    setCancelled(false);
+
+    // Create AbortController for this request
+    const abortController = new AbortController();
+    abortControllerRef.current = abortController;
+
+    // Add user message
+    const userMessage: Message = { role: "user", content: text };
+    setMessages((prev) => [...prev, userMessage]);
+
+    // Convert messages to chat format
+    const history: ChatMessage[] = messages.map((m) => ({
+      role: m.role,
+      content: m.content,
+    }));
+
+    // Create assistant message placeholder
+    const assistantMessage: Message = { role: "assistant", content: "", toolCalls: [] };
+    setMessages((prev) => [...prev, assistantMessage]);
+
+    try {
+      let fullContent = "";
+
+      for await (const event of streamProcessMessage(text, history, client, config, abortController.signal)) {
+        // Check if cancelled
+        if (abortController.signal.aborted) {
+          break;
+        }
+        switch (event.type) {
+          case "content":
+            fullContent += event.content || "";
+            setMessages((prev) => {
+              const updated = [...prev];
+              const last = updated[updated.length - 1];
+              if (last.role === "assistant") {
+                last.content = fullContent;
+              }
+              return updated;
+            });
+            break;
+
+          case "tool_use":
+            setCurrentTool(event.tool || null);
+            setToolStatus("running");
+            setMessages((prev) => {
+              const updated = [...prev];
+              const last = updated[updated.length - 1];
+              if (last.role === "assistant") {
+                last.toolCalls = [
+                  ...(last.toolCalls || []),
+                  { tool: event.tool!, status: "running" },
+                ];
+              }
+              return updated;
+            });
+            break;
+
+          case "tool_result":
+            setToolStatus(event.status as "complete" | "error");
+            setMessages((prev) => {
+              const updated = [...prev];
+              const last = updated[updated.length - 1];
+              if (last.role === "assistant" && last.toolCalls) {
+                const toolCall = last.toolCalls.find((tc) => tc.tool === event.tool);
+                if (toolCall) {
+                  toolCall.status = event.status as "complete" | "error";
+                  toolCall.result = event.result?.content || event.result?.error;
+                }
+              }
+              return updated;
+            });
+            setTimeout(() => {
+              setCurrentTool(null);
+              setToolStatus(null);
+            }, 500);
+            break;
+
+          case "error":
+            setError(event.error || "Unknown error");
+            break;
+
+          case "done":
+            break;
+        }
+      }
+    } catch (err) {
+      if (!abortController.signal.aborted) {
+        setError(String(err));
+      }
+    } finally {
+      setIsProcessing(false);
+      setCurrentTool(null);
+      setToolStatus(null);
+      abortControllerRef.current = null;
+    }
+  }, [messages, client, config, isProcessing]);
+
+  return (
+    <Box flexDirection="column" height="100%">
+      {/* Messages */}
+      <Box flexDirection="column" flexGrow={1}>
+        <MessageList messages={messages} />
+      </Box>
+
+      {/* Tool Status */}
+      {currentTool && (
+        <ToolStatus tool={currentTool} status={toolStatus || "running"} />
+      )}
+
+      {/* Error */}
+      {error && (
+        <Box marginY={1}>
+          <Text color="red">⚠ {error}</Text>
+        </Box>
+      )}
+
+      {/* Exit Warning */}
+      {exitPending && (
+        <Box marginY={1}>
+          <Text color="yellow">Press Ctrl+C again to exit</Text>
+        </Box>
+      )}
+
+      {/* Input */}
+      <InputBox
+        value={input}
+        onChange={setInput}
+        onSubmit={handleSubmit}
+        isProcessing={isProcessing}
+        placeholder="Type your message..."
+      />
+
+      {/* Status Bar */}
+      <StatusBar
+        model={config.ollama.model}
+        isProcessing={isProcessing}
+        messageCount={messages.length}
+      />
+    </Box>
+  );
+}

package/src/ui/components/InputBox.tsx

@@ -0,0 +1,37 @@
+import React from "react";
+import { Box, Text } from "ink";
+import TextInput from "ink-text-input";
+
+interface InputBoxProps {
+  value: string;
+  onChange: (value: string) => void;
+  onSubmit: (value: string) => void;
+  isProcessing: boolean;
+  placeholder?: string;
+}
+
+export function InputBox({
+  value,
+  onChange,
+  onSubmit,
+  isProcessing,
+  placeholder,
+}: InputBoxProps): React.ReactElement {
+  return (
+    <Box borderStyle="round" borderColor={isProcessing ? "gray" : "cyan"} paddingX={1}>
+      <Text color="green" bold>
+        {isProcessing ? "⏳" : "❯"}{" "}
+      </Text>
+      {isProcessing ? (
+        <Text color="gray">Processing...</Text>
+      ) : (
+        <TextInput
+          value={value}
+          onChange={onChange}
+          onSubmit={onSubmit}
+          placeholder={placeholder}
+        />
+      )}
+    </Box>
+  );
+}

package/src/ui/components/MessageList.tsx

@@ -0,0 +1,80 @@
+import React from "react";
+import { Box, Text } from "ink";
+
+interface ToolCall {
+  tool: string;
+  status: "running" | "complete" | "error";
+  result?: string;
+}
+
+interface Message {
+  role: "user" | "assistant";
+  content: string;
+  toolCalls?: ToolCall[];
+}
+
+interface MessageListProps {
+  messages: Message[];
+}
+
+export function MessageList({ messages }: MessageListProps): React.ReactElement {
+  if (messages.length === 0) {
+    return (
+      <Box marginY={1}>
+        <Text color="gray">Start a conversation by typing below...</Text>
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column">
+      {messages.map((message, index) => (
+        <MessageItem key={index} message={message} />
+      ))}
+    </Box>
+  );
+}
+
+function MessageItem({ message }: { message: Message }): React.ReactElement {
+  const isUser = message.role === "user";
+
+  return (
+    <Box flexDirection="column" marginY={1}>
+      {/* Role indicator */}
+      <Box>
+        <Text color={isUser ? "green" : "cyan"} bold>
+          {isUser ? "You" : "ACTIVO"}
+        </Text>
+      </Box>
+
+      {/* Tool calls */}
+      {message.toolCalls && message.toolCalls.length > 0 && (
+        <Box flexDirection="column" marginLeft={2} marginY={1}>
+          {message.toolCalls.map((tc, idx) => (
+            <Box key={idx}>
+              <Text color="gray">
+                {tc.status === "running" ? "🔄" : tc.status === "complete" ? "✓" : "✗"}{" "}
+              </Text>
+              <Text color={tc.status === "error" ? "red" : "yellow"}>{tc.tool}</Text>
+              {tc.status === "complete" && tc.result && (
+                <Text color="gray"> - {truncate(tc.result, 50)}</Text>
+              )}
+            </Box>
+          ))}
+        </Box>
+      )}
+
+      {/* Content */}
+      {message.content && (
+        <Box marginLeft={2}>
+          <Text wrap="wrap">{message.content}</Text>
+        </Box>
+      )}
+    </Box>
+  );
+}
+
+function truncate(text: string, maxLength: number): string {
+  if (text.length <= maxLength) return text;
+  return text.slice(0, maxLength) + "...";
+}

package/src/ui/components/StatusBar.tsx

@@ -0,0 +1,36 @@
+import React from "react";
+import { Box, Text } from "ink";
+
+interface StatusBarProps {
+  model: string;
+  isProcessing: boolean;
+  messageCount: number;
+}
+
+export function StatusBar({
+  model,
+  isProcessing,
+  messageCount,
+}: StatusBarProps): React.ReactElement {
+  return (
+    <Box justifyContent="space-between" paddingX={1} marginTop={1}>
+      <Box>
+        <Text color="gray">Model: </Text>
+        <Text color="cyan">{model}</Text>
+      </Box>
+
+      <Box>
+        <Text color="gray">Messages: </Text>
+        <Text color="white">{messageCount}</Text>
+      </Box>
+
+      <Box>
+        {isProcessing ? (
+          <Text color="yellow">● Processing</Text>
+        ) : (
+          <Text color="green">● Ready</Text>
+        )}
+      </Box>
+    </Box>
+  );
+}