@benzsiangco/jarvis 1.0.0 → 1.1.0

package/src/config/index.ts

@@ -0,0 +1,363 @@
+// Configuration loader for Jarvis
+import { homedir } from 'os';
+import { join, resolve } from 'path';
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
+import type { JarvisConfig, ProviderConfig, ModelConfig } from '../core/types';
+
+// Re-export JarvisConfig for use by other modules
+export type { JarvisConfig } from '../core/types';
+
+const CONFIG_FILE_NAME = 'jarvis.json';
+const CONFIG_DIR = join(homedir(), '.config', 'jarvis');
+
+// Default Antigravity models from opencode-antigravity-auth
+const defaultAntigravityModels: Record<string, ModelConfig> = {
+  'antigravity-gemini-3-pro': {
+    name: 'Gemini 3 Pro (Antigravity)',
+    limit: { context: 1048576, output: 65535 },
+    modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+    variants: {
+      low: { thinkingLevel: 'low' },
+      high: { thinkingLevel: 'high' },
+    },
+  },
+  'antigravity-gemini-3-flash': {
+    name: 'Gemini 3 Flash (Antigravity)',
+    limit: { context: 1048576, output: 65536 },
+    modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+    variants: {
+      minimal: { thinkingLevel: 'minimal' },
+      low: { thinkingLevel: 'low' },
+      medium: { thinkingLevel: 'medium' },
+      high: { thinkingLevel: 'high' },
+    },
+  },
+  'antigravity-claude-sonnet-4-5': {
+    name: 'Claude Sonnet 4.5 (Antigravity)',
+    limit: { context: 200000, output: 64000 },
+    modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+  },
+  'antigravity-claude-sonnet-4-5-thinking': {
+    name: 'Claude Sonnet 4.5 Thinking (Antigravity)',
+    limit: { context: 200000, output: 64000 },
+    modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+    variants: {
+      low: { thinkingConfig: { thinkingBudget: 8192 } },
+      max: { thinkingConfig: { thinkingBudget: 32768 } },
+    },
+  },
+  'antigravity-claude-opus-4-5-thinking': {
+    name: 'Claude Opus 4.5 Thinking (Antigravity)',
+    limit: { context: 200000, output: 64000 },
+    modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+    variants: {
+      low: { thinkingConfig: { thinkingBudget: 8192 } },
+      max: { thinkingConfig: { thinkingBudget: 32768 } },
+    },
+  },
+  'gemini-2.5-flash': {
+    name: 'Gemini 2.5 Flash (Gemini CLI)',
+    limit: { context: 1048576, output: 65536 },
+    modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+  },
+  'gemini-2.5-pro': {
+    name: 'Gemini 2.5 Pro (Gemini CLI)',
+    limit: { context: 1048576, output: 65536 },
+    modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+  },
+  'gemini-3-flash-preview': {
+    name: 'Gemini 3 Flash Preview (Gemini CLI)',
+    limit: { context: 1048576, output: 65536 },
+    modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+  },
+  'gemini-3-pro-preview': {
+    name: 'Gemini 3 Pro Preview (Gemini CLI)',
+    limit: { context: 1048576, output: 65535 },
+    modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+  },
+};
+
+// Default configuration
+const defaultConfig: JarvisConfig = {
+  $schema: 'https://opencode.ai/config.json',
+  model: 'google/antigravity-claude-sonnet-4-5',
+  plugin: ['opencode-antigravity-auth@latest'],
+  provider: {
+    google: {
+      models: defaultAntigravityModels,
+    },
+    anthropic: {
+      models: {
+        'claude-sonnet-4-20250514': {
+          name: 'Claude Sonnet 4',
+          limit: { context: 200000, output: 64000 },
+          modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+        },
+        'claude-haiku-4-20250514': {
+          name: 'Claude Haiku 4',
+          limit: { context: 200000, output: 64000 },
+          modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+        },
+        'claude-opus-4-20250514': {
+          name: 'Claude Opus 4',
+          limit: { context: 200000, output: 64000 },
+          modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+        },
+        'claude-3-5-sonnet-20241022': {
+          name: 'Claude 3.5 Sonnet',
+          limit: { context: 200000, output: 8192 },
+          modalities: { input: ['text', 'image'], output: ['text'] },
+        },
+      },
+    },
+    openai: {
+      models: {
+        'gpt-4o': {
+          name: 'GPT-4o',
+          limit: { context: 128000, output: 16384 },
+          modalities: { input: ['text', 'image'], output: ['text'] },
+        },
+        'gpt-4o-mini': {
+          name: 'GPT-4o Mini',
+          limit: { context: 128000, output: 16384 },
+          modalities: { input: ['text', 'image'], output: ['text'] },
+        },
+        'gpt-4-turbo': {
+          name: 'GPT-4 Turbo',
+          limit: { context: 128000, output: 4096 },
+          modalities: { input: ['text', 'image'], output: ['text'] },
+        },
+        'o1-preview': {
+          name: 'o1 Preview',
+          limit: { context: 128000, output: 32768 },
+          modalities: { input: ['text'], output: ['text'] },
+        },
+        'o1-mini': {
+          name: 'o1 Mini',
+          limit: { context: 128000, output: 65536 },
+          modalities: { input: ['text'], output: ['text'] },
+        },
+        'o3-mini': {
+          name: 'o3 Mini',
+          limit: { context: 128000, output: 65536 },
+          modalities: { input: ['text'], output: ['text'] },
+        },
+      },
+    },
+    groq: {
+      models: {
+        'llama-3.3-70b-versatile': {
+          name: 'Llama 3.3 70B',
+          limit: { context: 128000, output: 32768 },
+          modalities: { input: ['text'], output: ['text'] },
+        },
+        'llama-3.1-8b-instant': {
+          name: 'Llama 3.1 8B',
+          limit: { context: 128000, output: 8192 },
+          modalities: { input: ['text'], output: ['text'] },
+        },
+        'mixtral-8x7b-32768': {
+          name: 'Mixtral 8x7B',
+          limit: { context: 32768, output: 32768 },
+          modalities: { input: ['text'], output: ['text'] },
+        },
+        'gemma2-9b-it': {
+          name: 'Gemma 2 9B',
+          limit: { context: 8192, output: 8192 },
+          modalities: { input: ['text'], output: ['text'] },
+        },
+      },
+    },
+    mistral: {
+      models: {
+        'mistral-large-latest': {
+          name: 'Mistral Large',
+          limit: { context: 128000, output: 8192 },
+          modalities: { input: ['text'], output: ['text'] },
+        },
+        'mistral-medium-latest': {
+          name: 'Mistral Medium',
+          limit: { context: 32000, output: 8192 },
+          modalities: { input: ['text'], output: ['text'] },
+        },
+        'codestral-latest': {
+          name: 'Codestral',
+          limit: { context: 32000, output: 8192 },
+          modalities: { input: ['text'], output: ['text'] },
+        },
+        'open-mistral-nemo': {
+          name: 'Mistral Nemo',
+          limit: { context: 128000, output: 8192 },
+          modalities: { input: ['text'], output: ['text'] },
+        },
+      },
+    },
+    deepseek: {
+      models: {
+        'deepseek-chat': {
+          name: 'DeepSeek Chat',
+          limit: { context: 64000, output: 8192 },
+          modalities: { input: ['text'], output: ['text'] },
+        },
+        'deepseek-reasoner': {
+          name: 'DeepSeek Reasoner (R1)',
+          limit: { context: 64000, output: 8192 },
+          modalities: { input: ['text'], output: ['text'] },
+        },
+      },
+    },
+    xai: {
+      models: {
+        'grok-3': {
+          name: 'Grok 3',
+          limit: { context: 131072, output: 8192 },
+          modalities: { input: ['text'], output: ['text'] },
+        },
+        'grok-3-mini': {
+          name: 'Grok 3 Mini',
+          limit: { context: 131072, output: 8192 },
+          modalities: { input: ['text'], output: ['text'] },
+        },
+        'grok-2-1212': {
+          name: 'Grok 2',
+          limit: { context: 131072, output: 8192 },
+          modalities: { input: ['text', 'image'], output: ['text'] },
+        },
+      },
+    },
+    together: {
+      models: {
+        'meta-llama/Llama-3.3-70B-Instruct-Turbo': {
+          name: 'Llama 3.3 70B Turbo',
+          limit: { context: 131072, output: 8192 },
+          modalities: { input: ['text'], output: ['text'] },
+        },
+        'deepseek-ai/DeepSeek-R1': {
+          name: 'DeepSeek R1',
+          limit: { context: 128000, output: 8192 },
+          modalities: { input: ['text'], output: ['text'] },
+        },
+        'Qwen/Qwen2.5-Coder-32B-Instruct': {
+          name: 'Qwen 2.5 Coder 32B',
+          limit: { context: 32768, output: 8192 },
+          modalities: { input: ['text'], output: ['text'] },
+        },
+      },
+    },
+  },
+  tools: {
+    bash: true,
+    read: true,
+    write: true,
+    edit: true,
+    glob: true,
+    grep: true,
+    webfetch: true,
+    task: true,
+    todoread: true,
+    todowrite: true,
+    question: true,
+  },
+  permission: {
+    edit: 'allow',
+    bash: 'allow',
+    webfetch: 'allow',
+  },
+};
+
+export function getConfigDir(): string {
+  return CONFIG_DIR;
+}
+
+export function getGlobalConfigPath(): string {
+  return join(CONFIG_DIR, CONFIG_FILE_NAME);
+}
+
+export function getProjectConfigPath(projectDir?: string): string {
+  const dir = projectDir || process.cwd();
+  return join(dir, CONFIG_FILE_NAME);
+}
+
+export function ensureConfigDir(): void {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+export function loadConfig(projectDir?: string): JarvisConfig {
+  ensureConfigDir();
+  
+  let config: JarvisConfig = { ...defaultConfig };
+  
+  // Load global config
+  const globalConfigPath = getGlobalConfigPath();
+  if (existsSync(globalConfigPath)) {
+    try {
+      const globalConfig = JSON.parse(readFileSync(globalConfigPath, 'utf-8'));
+      config = mergeConfigs(config, globalConfig);
+    } catch (error) {
+      console.error(`Error loading global config: ${error}`);
+    }
+  }
+  
+  // Load project config
+  const projectConfigPath = getProjectConfigPath(projectDir);
+  if (existsSync(projectConfigPath)) {
+    try {
+      const projectConfig = JSON.parse(readFileSync(projectConfigPath, 'utf-8'));
+      config = mergeConfigs(config, projectConfig);
+    } catch (error) {
+      console.error(`Error loading project config: ${error}`);
+    }
+  }
+  
+  return config;
+}
+
+export function saveGlobalConfig(config: JarvisConfig): void {
+  ensureConfigDir();
+  writeFileSync(getGlobalConfigPath(), JSON.stringify(config, null, 2));
+}
+
+export function saveProjectConfig(config: Partial<JarvisConfig>, projectDir?: string): void {
+  const configPath = getProjectConfigPath(projectDir);
+  writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+
+function mergeConfigs(base: JarvisConfig, override: Partial<JarvisConfig>): JarvisConfig {
+  return {
+    ...base,
+    ...override,
+    provider: {
+      ...base.provider,
+      ...override.provider,
+    },
+    agent: {
+      ...base.agent,
+      ...override.agent,
+    },
+    tools: {
+      ...base.tools,
+      ...override.tools,
+    },
+    permission: {
+      ...base.permission,
+      ...override.permission,
+    },
+    plugin: override.plugin ?? base.plugin,
+  };
+}
+
+export function parseModelId(modelId: string): { providerId: string; modelId: string } {
+  const parts = modelId.split('/');
+  if (parts.length === 2 && parts[0] && parts[1]) {
+    return { providerId: parts[0], modelId: parts[1] };
+  }
+  // Default to google provider if no provider specified
+  return { providerId: 'google', modelId };
+}
+
+export function getModelConfig(config: JarvisConfig, modelId: string): ModelConfig | undefined {
+  const { providerId, modelId: model } = parseModelId(modelId);
+  return config.provider?.[providerId]?.models?.[model];
+}

package/src/core/executor.ts

@@ -0,0 +1,222 @@
+import { streamText, generateText, type CoreMessage, type Tool as AITool } from 'ai';
+import type { AgentConfig, Message, Session, Tool, ToolContext, ToolResult } from '../core/types';
+import { getModel } from '../providers';
+import { getTool, getAllTools } from '../tools';
+import { getAgentSystemPrompt, isToolEnabled } from '../agents';
+import { addMessage, getSession, setTodos, getTodos } from '../sessions';
+import { loadConfig } from '../config';
+
+// Convert our tools to AI SDK format
+function convertToolsToAIFormat(agent: AgentConfig, context: ToolContext): Record<string, AITool<any, any>> {
+  const aiTools: Record<string, AITool<any, any>> = {};
+  const allTools = getAllTools();
+
+  for (const tool of allTools) {
+    if (!isToolEnabled(agent, tool.name)) {
+      continue;
+    }
+
+    aiTools[tool.name] = {
+      description: tool.description,
+      parameters: tool.parameters as any,
+      execute: async (args: Record<string, unknown>) => {
+        // Handle security permissions
+        const permission = (agent.permission as any)?.[tool.name] || 'allow';
+        if (permission === 'deny') {
+          return { error: `Permission denied for tool: ${tool.name}` };
+        }
+        // In web/cli mode 'ask' defaults to 'allow' for now unless we implement interactive prompt
+        
+        console.log(`[EXECUTOR] Executing tool: ${tool.name}`);
+        return await tool.execute(args, context);
+      },
+    };
+  }
+
+  return aiTools;
+}
+
+function buildMessages(session: Session): CoreMessage[] {
+  const messages: CoreMessage[] = [];
+  for (const msg of session.messages) {
+    if (msg.role === 'user') {
+      messages.push({ role: 'user', content: msg.content });
+    } else if (msg.role === 'assistant') {
+      messages.push({ role: 'assistant', content: msg.content });
+    }
+  }
+  return messages;
+}
+
+export interface ExecutorOptions {
+  session: Session;
+  agent: AgentConfig;
+  modelOptions?: Record<string, unknown>;
+  onText?: (text: string) => void;
+  onToolStart?: (toolName: string, args: Record<string, unknown>) => void;
+  onToolEnd?: (toolName: string, result: ToolResult) => void;
+  onThinking?: (thinking: string) => void;
+  onError?: (error: Error) => void;
+  signal?: AbortSignal;
+}
+
+export interface ExecutorResult {
+  message: Message;
+  toolCalls: Array<{
+    name: string;
+    args: Record<string, unknown>;
+    result: ToolResult;
+  }>;
+  usage?: any;
+}
+
+export async function executeAgent(
+  userMessage: string,
+  options: ExecutorOptions
+): Promise<ExecutorResult> {
+  const { session, agent, modelOptions, onText, onToolStart, onToolEnd, onThinking, onError, signal } = options;
+  const config = loadConfig();
+
+  const modelId = agent.model || config.model || 'google/antigravity-claude-sonnet-4-5-thinking';
+  const model = getModel(modelId, modelOptions);
+
+  if (!model) {
+    throw new Error(`Model not found: ${modelId}`);
+  }
+
+  addMessage(session.id, { role: 'user', content: userMessage });
+
+  const toolContext: ToolContext = {
+    workdir: session.workdir || process.cwd(),
+    session,
+    signal,
+  };
+
+  const tools = convertToolsToAIFormat(agent, toolContext);
+  const messages = buildMessages(session);
+  const systemPrompt = getAgentSystemPrompt(agent);
+
+  const toolCalls: ExecutorResult['toolCalls'] = [];
+  let fullText = '';
+
+  try {
+    const result = await streamText({
+      model,
+      system: systemPrompt,
+      messages,
+      tools,
+      maxSteps: agent.maxSteps || 50,
+      temperature: agent.temperature,
+      abortSignal: signal,
+    });
+    
+    for await (const part of result.fullStream) {
+      if (part.type === 'text-delta') {
+        if (onText) onText(part.textDelta);
+        fullText += part.textDelta;
+      } else if (part.type === 'tool-call') {
+        if (onToolStart) onToolStart(part.toolName, part.args as Record<string, unknown>);
+      } else if (part.type === 'reasoning') {
+        if (onThinking) onThinking(part.textDelta);
+      }
+    }
+
+    const steps = await result.steps;
+    for (const step of steps) {
+      for (const tc of step.toolCalls) {
+        const foundResult = step.toolResults.find((tr: any) => tr.toolCallId === tc.toolCallId);
+        toolCalls.push({
+          name: tc.toolName,
+          args: tc.args as Record<string, unknown>,
+          result: (foundResult as any)?.result as ToolResult,
+        });
+        if (onToolEnd) onToolEnd(tc.toolName, (foundResult as any)?.result as ToolResult);
+      }
+    }
+
+    const usage = await result.usage;
+    const assistantMessage = addMessage(session.id, {
+      role: 'assistant',
+      content: fullText,
+      parts: toolCalls.map(tc => ({
+        type: 'tool_call' as const,
+        content: JSON.stringify(tc.result),
+        toolName: tc.name,
+        toolArgs: tc.args,
+        toolResult: tc.result,
+      })),
+      metadata: { usage },
+    });
+
+    return { message: assistantMessage, toolCalls, usage };
+  } catch (err) {
+    if (onError) onError(err as Error);
+    throw err;
+  }
+}
+
+export async function executeAgentSync(
+  userMessage: string,
+  options: Omit<ExecutorOptions, 'onText' | 'onToolStart' | 'onToolEnd' | 'onThinking'>
+): Promise<ExecutorResult> {
+  const { session, agent, signal } = options;
+  const config = loadConfig();
+
+  const modelId = agent.model || config.model || 'google/antigravity-claude-sonnet-4-5-thinking';
+  const model = getModel(modelId);
+
+  if (!model) {
+    throw new Error(`Model not found: ${modelId}`);
+  }
+
+  addMessage(session.id, { role: 'user', content: userMessage });
+
+  const toolContext: ToolContext = {
+    workdir: session.workdir || process.cwd(),
+    session,
+    signal,
+  };
+
+  const tools = convertToolsToAIFormat(agent, toolContext);
+  const messages = buildMessages(session);
+  const systemPrompt = getAgentSystemPrompt(agent);
+
+  const result = await generateText({
+    model,
+    system: systemPrompt,
+    messages,
+    tools,
+    maxSteps: agent.maxSteps || 50,
+    temperature: agent.temperature,
+    abortSignal: signal,
+  });
+
+  const toolCalls: ExecutorResult['toolCalls'] = [];
+  for (const step of result.steps) {
+    for (const tc of step.toolCalls) {
+      const toolResult = step.toolResults.find((tr: any) => tr.toolCallId === tc.toolCallId);
+      if (toolResult) {
+        toolCalls.push({
+          name: tc.toolName,
+          args: tc.args as Record<string, unknown>,
+          result: (toolResult as any).result as ToolResult,
+        });
+      }
+    }
+  }
+
+  const assistantMessage = addMessage(session.id, {
+    role: 'assistant',
+    content: result.text,
+    parts: toolCalls.map(tc => ({
+      type: 'tool_call' as const,
+      content: JSON.stringify(tc.result),
+      toolName: tc.name,
+      toolArgs: tc.args,
+      toolResult: tc.result,
+    })),
+    metadata: { usage: result.usage },
+  });
+
+  return { message: assistantMessage, toolCalls, usage: result.usage };
+}