activo 0.4.3 → 0.5.0

package/src/core/tools/types.ts

@@ -1,38 +0,0 @@
-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;
-  items?: { type: string };
-}
-
-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

@@ -1,334 +0,0 @@
-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 { handleSlashCommand } from "../core/commands.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";
-import {
-  createSession,
-  loadLatestSession,
-  saveSession,
-  getSessionContext,
-  cleanOldSessions,
-} from "../core/conversation.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 [currentModel, setCurrentModel] = useState(config.ollama.model);
-  const [exitPending, setExitPending] = useState(false);
-  const [cancelled, setCancelled] = useState(false);
-  const abortControllerRef = useRef<AbortController | null>(null);
-
-  // Session management
-  const [session, setSession] = useState(() => createSession());
-  const [contextSummary, setContextSummary] = useState<string>("");
-
-  // 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]);
-
-  // Load previous session context on mount (if resume)
-  useEffect(() => {
-    const loadContext = async () => {
-      if (resume) {
-        try {
-          const { summary, recentMessages } = await getSessionContext(client, 5);
-          if (summary) {
-            setContextSummary(summary);
-          }
-          // Optionally load recent messages to display
-          if (recentMessages.length > 0) {
-            const displayMessages: Message[] = recentMessages
-              .filter(m => m.role === "user" || m.role === "assistant")
-              .map(m => ({
-                role: m.role as "user" | "assistant",
-                content: m.content,
-              }));
-            setMessages(displayMessages);
-          }
-        } catch {
-          // Ignore context loading errors
-        }
-      }
-      // Clean old sessions
-      cleanOldSessions(10);
-    };
-    loadContext();
-  }, [resume, client]);
-
-  // Process initial prompt
-  useEffect(() => {
-    if (initialPrompt) {
-      handleSubmit(initialPrompt);
-    }
-  }, [initialPrompt]);
-
-  const handleSubmit = useCallback(async (text: string) => {
-    if (!text.trim() || isProcessing) return;
-
-    setInput("");
-    setError(null);
-
-    // Handle slash commands first
-    if (text.startsWith("/")) {
-      const result = handleSlashCommand(text, config);
-      if (result) {
-        // Add command as user message
-        setMessages((prev) => [...prev, { role: "user", content: text }]);
-
-        if (result.exit) {
-          const exitMsg: Message = { role: "assistant", content: result.output || "Goodbye!" };
-          setMessages((prev) => [...prev, exitMsg]);
-          setTimeout(() => exit(), 500);
-          return;
-        }
-
-        if (result.clear) {
-          setMessages([]);
-          return;
-        }
-
-        if (result.changeModel) {
-          setCurrentModel(result.changeModel);
-          client.setModel(result.changeModel);
-        }
-
-        if (result.output) {
-          const outputMsg: Message = { role: "assistant", content: result.output };
-          setMessages((prev) => [...prev, outputMsg]);
-        }
-
-        return;
-      }
-    }
-
-    setIsProcessing(true);
-    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, contextSummary)) {
-        // 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;
-
-      // Save conversation to session
-      setSession((prevSession) => {
-        const updatedSession = { ...prevSession };
-        // Add user message
-        updatedSession.messages.push({ role: "user", content: text });
-        // Add assistant message (get from current messages state)
-        setMessages((currentMessages) => {
-          const lastMessage = currentMessages[currentMessages.length - 1];
-          if (lastMessage?.role === "assistant") {
-            updatedSession.messages.push({
-              role: "assistant",
-              content: lastMessage.content,
-            });
-          }
-          return currentMessages;
-        });
-        saveSession(updatedSession);
-        return updatedSession;
-      });
-    }
-  }, [messages, client, config, isProcessing, contextSummary]);
-
-  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={currentModel}
-        isProcessing={isProcessing}
-        messageCount={messages.length}
-      />
-    </Box>
-  );
-}

package/src/ui/components/InputBox.tsx

@@ -1,37 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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>
-  );
-}

package/src/ui/components/ToolStatus.tsx

@@ -1,38 +0,0 @@
-import React from "react";
-import { Box, Text } from "ink";
-import Spinner from "ink-spinner";
-
-interface ToolStatusProps {
-  tool: string;
-  status: "running" | "complete" | "error";
-}
-
-export function ToolStatus({ tool, status }: ToolStatusProps): React.ReactElement {
-  return (
-    <Box marginY={1} paddingX={1}>
-      {status === "running" ? (
-        <>
-          <Text color="cyan">
-            <Spinner type="dots" />
-          </Text>
-          <Text color="cyan"> Using tool: </Text>
-          <Text color="yellow" bold>
-            {tool}
-          </Text>
-        </>
-      ) : status === "complete" ? (
-        <>
-          <Text color="green">✓ </Text>
-          <Text color="gray">Tool completed: </Text>
-          <Text color="white">{tool}</Text>
-        </>
-      ) : (
-        <>
-          <Text color="red">✗ </Text>
-          <Text color="gray">Tool failed: </Text>
-          <Text color="red">{tool}</Text>
-        </>
-      )}
-    </Box>
-  );
-}

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2022"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "jsx": "react-jsx"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}