erosolar-cli 1.0.1

package/dist/capabilities/tavilyCapability.js

@@ -0,0 +1,26 @@
+import { createTavilyTools } from '../tools/tavilyTools.js';
+export class TavilyCapabilityModule {
+    id = 'capability.tavily';
+    options;
+    constructor(options) {
+        if (!options?.apiKey) {
+            throw new Error('TavilyCapabilityModule requires an API key.');
+        }
+        this.options = options;
+    }
+    async create(_context) {
+        const tools = createTavilyTools({
+            apiKey: this.options.apiKey,
+            baseUrl: this.options.baseUrl,
+        });
+        return {
+            id: 'tavily.tools.web',
+            description: 'Live Tavily web search and extraction tools.',
+            toolSuite: {
+                id: 'tavily.web',
+                description: 'Internet search and content extraction via Tavily.',
+                tools,
+            },
+        };
+    }
+}

package/dist/capabilities/toolRegistry.js

@@ -0,0 +1,98 @@
+import { getSecretValue } from '../core/secretStore.js';
+const TOOL_OPTIONS = [
+    {
+        id: 'filesystem',
+        label: 'File operations',
+        description: 'Read, write, list, and search files inside the workspace.',
+        defaultEnabled: true,
+        pluginIds: ['tool.filesystem.local'],
+    },
+    {
+        id: 'search',
+        label: 'Repository search',
+        description: 'Structural and glob-aware search helpers (grep, find definition).',
+        defaultEnabled: true,
+        pluginIds: ['tool.search.local'],
+    },
+    {
+        id: 'bash',
+        label: 'Shell access',
+        description: 'Run commands inside a sandboxed Bash shell.',
+        defaultEnabled: true,
+        pluginIds: ['tool.bash.local'],
+    },
+    {
+        id: 'tavily',
+        label: 'Tavily web search',
+        description: 'Live web search and extraction powered by Tavily.',
+        defaultEnabled: false,
+        pluginIds: ['tool.tavily.web'],
+        requiresSecret: 'TAVILY_API_KEY',
+    },
+];
+const PLUGIN_TO_OPTION = buildPluginLookup();
+export function getToolToggleOptions() {
+    return [...TOOL_OPTIONS];
+}
+export function buildEnabledToolSet(saved) {
+    const enabled = new Set();
+    if (!saved) {
+        for (const option of TOOL_OPTIONS) {
+            if (option.defaultEnabled) {
+                enabled.add(option.id);
+            }
+        }
+        return enabled;
+    }
+    const knownIds = new Set(TOOL_OPTIONS.map((option) => option.id));
+    for (const id of saved.enabledTools ?? []) {
+        if (knownIds.has(id)) {
+            enabled.add(id);
+        }
+    }
+    return enabled;
+}
+export function evaluateToolPermissions(selection) {
+    const allowedPluginIds = new Set();
+    const warnings = [];
+    for (const option of TOOL_OPTIONS) {
+        if (!selection.has(option.id)) {
+            continue;
+        }
+        if (option.requiresSecret) {
+            const secret = getSecretValue(option.requiresSecret);
+            if (!secret) {
+                warnings.push({
+                    id: option.id,
+                    label: option.label,
+                    reason: 'missing-secret',
+                    secretId: option.requiresSecret,
+                });
+                continue;
+            }
+        }
+        for (const pluginId of option.pluginIds) {
+            allowedPluginIds.add(pluginId);
+        }
+    }
+    return {
+        allowedPluginIds,
+        warnings,
+    };
+}
+export function isPluginEnabled(pluginId, allowedPluginIds) {
+    const associated = PLUGIN_TO_OPTION.get(pluginId);
+    if (!associated) {
+        return true;
+    }
+    return allowedPluginIds.has(pluginId);
+}
+function buildPluginLookup() {
+    const map = new Map();
+    for (const option of TOOL_OPTIONS) {
+        for (const pluginId of option.pluginIds) {
+            map.set(pluginId, option);
+        }
+    }
+    return map;
+}

package/dist/config.js

@@ -0,0 +1,60 @@
+import { registerAgentProfile, hasAgentProfile, getAgentProfile, } from './core/agentProfiles.js';
+const DEFAULT_PROFILES = [
+    {
+        name: 'general',
+        label: 'Erosolar',
+        description: 'General-purpose operator with balanced reasoning across research, planning, writing, and coding tasks.',
+        defaultProvider: 'openai',
+        defaultModel: 'gpt-5.1',
+        defaultSystemPrompt: 'You are the Erosolar General Agent, a multi-domain operator who can plan work, write documents, reason about data, and modify code with equal rigor. Always ground answers in verifiable evidence: cite files, command output, or captured context. Narrate your intent, decompose complex requests into steps, and reach for tools whenever direct inspection or execution is required.',
+        temperature: 0.2,
+    },
+    {
+        name: 'erosolar-code',
+        label: 'Erosolar Code',
+        description: 'OpenAI-tuned coding specialist optimized for rapid edits with deterministic grounding.',
+        defaultProvider: 'openai',
+        defaultModel: 'gpt-5.1-codex',
+        defaultSystemPrompt: 'You are the Erosolar CLI, a powerful AI coding assistant with full capabilities. You can read and write files, execute bash commands, search codebases, and handle complex multi-step tasks. Be proactive and use tools to accomplish tasks effectively.',
+    },
+];
+for (const profile of DEFAULT_PROFILES) {
+    if (!hasAgentProfile(profile.name)) {
+        registerAgentProfile(profile);
+    }
+}
+export function resolveProfileConfig(profile, workspaceContext) {
+    const blueprint = getAgentProfile(profile);
+    const envPrefix = toEnvPrefix(blueprint.name);
+    const modelEnv = process.env[`${envPrefix}_MODEL`];
+    const modelLocked = typeof modelEnv === 'string' && modelEnv.trim().length > 0;
+    const model = modelLocked ? modelEnv.trim() : blueprint.defaultModel;
+    // System prompt can still be customized via environment if needed
+    const systemPrompt = process.env[`${envPrefix}_SYSTEM_PROMPT`] ?? blueprint.defaultSystemPrompt;
+    const providerEnv = process.env[`${envPrefix}_PROVIDER`];
+    const providerLocked = isProviderValue(providerEnv);
+    const provider = providerLocked ? providerEnv.trim() : blueprint.defaultProvider;
+    const contextBlock = workspaceContext?.trim()
+        ? `\n\nWorkspace context (auto-detected):\n${workspaceContext.trim()}`
+        : '';
+    return {
+        profile,
+        label: blueprint.label,
+        provider,
+        model,
+        temperature: blueprint.temperature,
+        maxTokens: blueprint.maxTokens,
+        systemPrompt: `${systemPrompt.trim()}${contextBlock}`,
+        modelLocked,
+        providerLocked,
+    };
+}
+function toEnvPrefix(profile) {
+    return profile
+        .trim()
+        .toUpperCase()
+        .replace(/[^A-Z0-9]/g, '_');
+}
+function isProviderValue(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}

package/dist/contracts/v1/agent.js

@@ -0,0 +1,7 @@
+/**
+ * Agent Contract v1.0
+ *
+ * Stable interface for agent interaction across all frontends.
+ * Breaking changes require a new version (v2/).
+ */
+export const AGENT_CONTRACT_VERSION = '1.0.0';

package/dist/contracts/v1/provider.js

@@ -0,0 +1,6 @@
+/**
+ * Provider Contract v1.0
+ *
+ * Stable interface for LLM provider integration.
+ */
+export const PROVIDER_CONTRACT_VERSION = '1.0.0';

package/dist/contracts/v1/tool.js

@@ -0,0 +1,6 @@
+/**
+ * Tool Contract v1.0
+ *
+ * Stable interface for tool registration and execution.
+ */
+export const TOOL_CONTRACT_VERSION = '1.0.0';

package/dist/core/agent.js

@@ -0,0 +1,135 @@
+export class AgentRuntime {
+    messages = [];
+    provider;
+    toolRuntime;
+    callbacks;
+    activeRun = null;
+    baseSystemPrompt;
+    constructor(options) {
+        this.provider = options.provider;
+        this.toolRuntime = options.toolRuntime;
+        this.callbacks = options.callbacks ?? {};
+        const trimmedPrompt = options.systemPrompt.trim();
+        this.baseSystemPrompt = trimmedPrompt || null;
+        if (trimmedPrompt) {
+            this.messages.push({ role: 'system', content: trimmedPrompt });
+        }
+    }
+    async send(text) {
+        const prompt = text.trim();
+        if (!prompt) {
+            return '';
+        }
+        this.messages.push({ role: 'user', content: prompt });
+        const run = { startedAt: Date.now() };
+        this.activeRun = run;
+        try {
+            return await this.processConversation();
+        }
+        finally {
+            if (this.activeRun === run) {
+                this.activeRun = null;
+            }
+        }
+    }
+    async processConversation() {
+        while (true) {
+            const response = await this.provider.generate(this.messages, this.providerTools);
+            const usage = response.usage ?? null;
+            if (response.type === 'tool_calls') {
+                const narration = response.content?.trim();
+                if (narration) {
+                    this.emitAssistantMessage(narration, { isFinal: false, usage });
+                }
+                this.messages.push({
+                    role: 'assistant',
+                    content: response.content ?? '',
+                    toolCalls: response.toolCalls,
+                });
+                await this.resolveToolCalls(response.toolCalls);
+                continue;
+            }
+            const reply = response.content?.trim() ?? '';
+            if (reply) {
+                this.emitAssistantMessage(reply, { isFinal: true, usage });
+            }
+            this.messages.push({ role: 'assistant', content: reply });
+            return reply;
+        }
+        throw new Error('Agent loop exited unexpectedly.');
+    }
+    async resolveToolCalls(toolCalls) {
+        for (const call of toolCalls) {
+            const output = await this.toolRuntime.execute(call);
+            this.messages.push({
+                role: 'tool',
+                name: call.name,
+                toolCallId: call.id,
+                content: output,
+            });
+        }
+    }
+    get providerTools() {
+        return this.toolRuntime.listProviderTools();
+    }
+    emitAssistantMessage(content, metadata) {
+        if (!content) {
+            return;
+        }
+        const elapsedMs = this.activeRun ? Date.now() - this.activeRun.startedAt : undefined;
+        this.callbacks.onAssistantMessage?.(content, {
+            ...metadata,
+            elapsedMs,
+        });
+    }
+    getHistory() {
+        return this.messages.map(cloneMessage);
+    }
+    loadHistory(history) {
+        this.messages.length = 0;
+        if (history.length === 0) {
+            if (this.baseSystemPrompt) {
+                this.messages.push({ role: 'system', content: this.baseSystemPrompt });
+            }
+            return;
+        }
+        for (const message of history) {
+            this.messages.push(cloneMessage(message));
+        }
+    }
+    clearHistory() {
+        this.messages.length = 0;
+        if (this.baseSystemPrompt) {
+            this.messages.push({ role: 'system', content: this.baseSystemPrompt });
+        }
+    }
+}
+function cloneMessage(message) {
+    switch (message.role) {
+        case 'assistant':
+            return {
+                role: 'assistant',
+                content: message.content,
+                toolCalls: message.toolCalls?.map(cloneToolCall),
+            };
+        case 'tool':
+            return {
+                role: 'tool',
+                name: message.name,
+                content: message.content,
+                toolCallId: message.toolCallId,
+            };
+        case 'system':
+            return { role: 'system', content: message.content };
+        case 'user':
+        default:
+            return { role: 'user', content: message.content };
+    }
+}
+function cloneToolCall(call) {
+    return {
+        id: call.id,
+        name: call.name,
+        arguments: { ...(call.arguments ?? {}) },
+    };
+}

package/dist/core/agentProfiles.js

@@ -0,0 +1,34 @@
+const registry = new Map();
+export function registerAgentProfile(blueprint) {
+    if (!blueprint?.name) {
+        throw new Error('Agent profile name is required.');
+    }
+    const trimmedName = blueprint.name.trim();
+    if (!trimmedName) {
+        throw new Error('Agent profile name cannot be blank.');
+    }
+    const payload = Object.freeze({
+        ...blueprint,
+        name: trimmedName,
+        label: blueprint.label.trim() || trimmedName,
+        frozen: true,
+    });
+    registry.set(trimmedName, payload);
+}
+export function hasAgentProfile(name) {
+    return registry.has(name.trim());
+}
+export function getAgentProfile(name) {
+    const profile = registry.get(name.trim());
+    if (!profile) {
+        const known = listAgentProfiles()
+            .map((entry) => entry.name)
+            .sort()
+            .join(', ');
+        throw new Error(`Unknown profile "${name}". Registered profiles: ${known || 'none'}.`);
+    }
+    return profile;
+}
+export function listAgentProfiles() {
+    return Array.from(registry.values());
+}

package/dist/core/contextWindow.js

@@ -0,0 +1,29 @@
+const MODEL_CONTEXT_WINDOWS = [
+    { pattern: /^gpt-5\.1-?codex$/i, tokens: 200_000 },
+    { pattern: /^gpt-5(?:\.1|-?pro|-?mini|-?nano)/i, tokens: 200_000 },
+    { pattern: /^claude-sonnet-4[-.]?5/i, tokens: 200_000 },
+    { pattern: /^claude-opus-4[-.]?1/i, tokens: 200_000 },
+    { pattern: /^claude-haiku-4[-.]?5/i, tokens: 200_000 },
+    { pattern: /sonnet-4[-.]?5/i, tokens: 200_000 },
+    { pattern: /opus-4[-.]?1/i, tokens: 200_000 },
+    { pattern: /haiku-4[-.]?5/i, tokens: 200_000 },
+];
+/**
+ * Returns the approximate context window (in tokens) for the provided model id.
+ * Falls back to null when the model is unknown so callers can handle gracefully.
+ */
+export function getContextWindowTokens(model) {
+    if (!model) {
+        return null;
+    }
+    const normalized = model.trim();
+    if (!normalized) {
+        return null;
+    }
+    for (const entry of MODEL_CONTEXT_WINDOWS) {
+        if (entry.pattern.test(normalized)) {
+            return entry.tokens;
+        }
+    }
+    return null;
+}

package/dist/core/errors/apiKeyErrors.js

@@ -0,0 +1,114 @@
+import { MissingSecretError, getSecretDefinitionForProvider, } from '../secretStore.js';
+export function detectApiKeyError(error, provider) {
+    if (error instanceof MissingSecretError) {
+        const primaryProvider = error.secret.providers[0] ?? null;
+        return {
+            type: 'missing',
+            provider: provider ?? primaryProvider,
+            secret: error.secret,
+            message: error.message,
+        };
+    }
+    if (isUnauthorizedError(error)) {
+        const labelProvider = provider ?? extractProviderFromError(error);
+        const secret = labelProvider ? getSecretDefinitionForProvider(labelProvider) : null;
+        return {
+            type: 'invalid',
+            provider: labelProvider,
+            secret,
+            message: extractErrorMessage(error),
+        };
+    }
+    return null;
+}
+function isUnauthorizedError(error) {
+    const status = extractStatus(error);
+    if (status === 401 || status === 403) {
+        return true;
+    }
+    const payload = extractStructuredError(error);
+    if (payload) {
+        const normalizedType = normalize(payload.type) || normalize(payload.code);
+        if (normalizedType && containsAuthKeyword(normalizedType)) {
+            return true;
+        }
+        if (payload.message && containsAuthKeyword(normalize(payload.message))) {
+            return true;
+        }
+    }
+    const message = normalize(extractErrorMessage(error));
+    if (!message) {
+        return false;
+    }
+    return containsAuthKeyword(message);
+}
+function extractStatus(error) {
+    if (!error || typeof error !== 'object') {
+        return null;
+    }
+    const directStatus = error.status;
+    if (typeof directStatus === 'number') {
+        return directStatus;
+    }
+    const response = error.response;
+    if (response && typeof response.status === 'number') {
+        return response.status;
+    }
+    return null;
+}
+function extractStructuredError(error) {
+    if (!error || typeof error !== 'object') {
+        return null;
+    }
+    if ('error' in error) {
+        const candidate = error.error;
+        if (candidate && typeof candidate === 'object') {
+            return candidate;
+        }
+    }
+    return null;
+}
+function extractProviderFromError(error) {
+    if (!error || typeof error !== 'object') {
+        return null;
+    }
+    const provider = error.provider;
+    if (typeof provider === 'string' && provider.trim()) {
+        return provider.trim();
+    }
+    return null;
+}
+function extractErrorMessage(error) {
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (error instanceof Error) {
+        return error.message ?? '';
+    }
+    if (error && typeof error === 'object') {
+        const payload = extractStructuredError(error);
+        if (payload?.message) {
+            return payload.message;
+        }
+        if ('message' in error && typeof error.message === 'string') {
+            return error.message;
+        }
+    }
+    return '';
+}
+function containsAuthKeyword(value) {
+    if (!value) {
+        return false;
+    }
+    return (value.includes('api key') ||
+        value.includes('apikey') ||
+        value.includes('api-key') ||
+        value.includes('authentication') ||
+        value.includes('unauthorized'));
+}
+function normalize(value) {
+    if (!value) {
+        return null;
+    }
+    return value.toLowerCase();
+}

package/dist/core/preferences.js

@@ -0,0 +1,157 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const CONFIG_DIR = join(homedir(), '.erosolar');
+const SETTINGS_PATH = join(CONFIG_DIR, 'settings.json');
+const CURRENT_VERSION = 2;
+export function loadActiveProfilePreference() {
+    const payload = readSettingsFile();
+    if (!payload?.activeProfile) {
+        return null;
+    }
+    return normalizeProfileNameValue(payload.activeProfile);
+}
+export function saveActiveProfilePreference(profile) {
+    const normalized = normalizeProfileNameValue(profile);
+    if (!normalized) {
+        return;
+    }
+    const payload = readSettingsFile() ?? { version: CURRENT_VERSION, profiles: {} };
+    payload.version = CURRENT_VERSION;
+    payload.profiles = payload.profiles ?? {};
+    payload.activeProfile = normalized;
+    writeSettingsFile(payload);
+}
+export function clearActiveProfilePreference() {
+    const payload = readSettingsFile();
+    if (!payload?.activeProfile) {
+        return;
+    }
+    payload.version = CURRENT_VERSION;
+    payload.profiles = payload.profiles ?? {};
+    delete payload.activeProfile;
+    writeSettingsFile(payload);
+}
+export function loadModelPreference(profile) {
+    const payload = readSettingsFile();
+    if (!payload) {
+        return null;
+    }
+    const entry = payload.profiles?.[profile];
+    if (!entry || typeof entry !== 'object') {
+        return null;
+    }
+    if (typeof entry.provider !== 'string' || typeof entry.model !== 'string') {
+        return null;
+    }
+    return { ...entry };
+}
+export function saveModelPreference(profile, preference) {
+    const payload = readSettingsFile() ?? { version: CURRENT_VERSION, profiles: {} };
+    payload.version = CURRENT_VERSION;
+    payload.profiles = payload.profiles ?? {};
+    payload.profiles[profile] = { ...preference };
+    writeSettingsFile(payload);
+}
+export function loadToolSettings() {
+    const payload = readSettingsFile();
+    if (!payload?.tools) {
+        return null;
+    }
+    const enabledTools = normalizeToolIds(payload.tools.enabledTools);
+    return { enabledTools };
+}
+export function saveToolSettings(settings) {
+    const payload = readSettingsFile() ?? { version: CURRENT_VERSION, profiles: {} };
+    payload.version = CURRENT_VERSION;
+    payload.profiles = payload.profiles ?? {};
+    payload.tools = {
+        enabledTools: normalizeToolIds(settings.enabledTools),
+    };
+    writeSettingsFile(payload);
+}
+export function clearToolSettings() {
+    const payload = readSettingsFile();
+    if (!payload) {
+        return;
+    }
+    payload.version = CURRENT_VERSION;
+    payload.profiles = payload.profiles ?? {};
+    if (payload.tools) {
+        delete payload.tools;
+    }
+    writeSettingsFile(payload);
+}
+function readSettingsFile() {
+    try {
+        if (!existsSync(SETTINGS_PATH)) {
+            return null;
+        }
+        const raw = readFileSync(SETTINGS_PATH, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object') {
+            return null;
+        }
+        const profiles = typeof parsed.profiles === 'object' && parsed.profiles !== null ? parsed.profiles : {};
+        const activeProfile = typeof parsed.activeProfile === 'string' && parsed.activeProfile.trim()
+            ? parsed.activeProfile.trim()
+            : undefined;
+        return {
+            version: typeof parsed.version === 'number' ? parsed.version : CURRENT_VERSION,
+            profiles,
+            tools: parseToolSettings(parsed.tools),
+            activeProfile,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function writeSettingsFile(payload) {
+    try {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+        writeFileSync(SETTINGS_PATH, JSON.stringify(payload, null, 2));
+    }
+    catch {
+        // Persistence failures should not crash the CLI; ignore write errors.
+    }
+}
+function parseToolSettings(value) {
+    if (!value || typeof value !== 'object') {
+        return undefined;
+    }
+    const record = value;
+    if (!Array.isArray(record.enabledTools)) {
+        return { enabledTools: [] };
+    }
+    return { enabledTools: normalizeToolIds(record.enabledTools) };
+}
+function normalizeToolIds(ids) {
+    if (!Array.isArray(ids)) {
+        return [];
+    }
+    const seen = new Set();
+    const result = [];
+    for (const entry of ids) {
+        if (typeof entry !== 'string') {
+            continue;
+        }
+        const id = entry.trim();
+        if (!id || seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        result.push(id);
+    }
+    return result;
+}
+function normalizeProfileNameValue(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    return trimmed;
+}