erosolar-cli 1.7.55 → 1.7.57

package/dist/bin/runtime/universal.js

@@ -1,28 +0,0 @@
-import { AgentHost } from './agentHost.js';
-export async function createUniversalRuntime(options) {
-    const env = options.env ? { ...options.env } : { ...process.env };
-    const host = new AgentHost({
-        profile: options.profile,
-        workspaceContext: options.workspaceContext,
-        workingDir: options.workingDir,
-        toolObserver: options.toolObserver,
-        env,
-    });
-    const adapterContext = {
-        profile: options.profile,
-        workspaceContext: options.workspaceContext,
-        workingDir: options.workingDir,
-        env,
-    };
-    const adapterModules = await options.adapter.createCapabilityModules(adapterContext);
-    const additionalModules = options.additionalModules ?? [];
-    if (adapterModules.length || additionalModules.length) {
-        await host.loadModules([...adapterModules, ...additionalModules]);
-    }
-    const session = await host.getSession();
-    return {
-        host,
-        session,
-        adapter: options.adapter,
-    };
-}

package/dist/bin/skills/skillRepository.js

@@ -1,236 +0,0 @@
-/**
- * Skill Repository
- *
- * Manages skill discovery, loading, and execution.
- * Skills are reusable code patterns that can be applied
- * across different contexts.
- */
-import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-// Simple globSync implementation for ESM compatibility
-function globSync(_pattern, options) {
-    const results = [];
-    function scanDir(dir, relativePath = '') {
-        try {
-            const entries = readdirSync(dir);
-            for (const entry of entries) {
-                const fullPath = join(dir, entry);
-                const relPath = relativePath ? `${relativePath}/${entry}` : entry;
-                try {
-                    const stat = statSync(fullPath);
-                    if (stat.isDirectory()) {
-                        scanDir(fullPath, relPath);
-                    }
-                    else if (entry.endsWith('.skill.json')) {
-                        results.push(relPath);
-                    }
-                }
-                catch {
-                    // Skip entries we can't stat
-                }
-            }
-        }
-        catch {
-            // Directory doesn't exist or can't be read
-        }
-    }
-    scanDir(options.cwd);
-    return results;
-}
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-export class SkillRepository {
-    constructor(_options = {}) {
-        this.skills = new Map();
-        this.skillPatterns = new Map();
-        // Options reserved for future extension (workspace paths, etc.)
-        this.loadBuiltInSkills();
-    }
-    /**
-     * Load built-in skills from the skills directory
-     */
-    loadBuiltInSkills() {
-        const skillsDir = join(__dirname, '..', '..', 'skills');
-        if (!existsSync(skillsDir)) {
-            // Silently skip - skills are optional
-            return;
-        }
-        try {
-            const skillFiles = globSync('**/*.skill.json', { cwd: skillsDir });
-            for (const skillFile of skillFiles) {
-                try {
-                    const skillPath = join(skillsDir, skillFile);
-                    const skillData = JSON.parse(readFileSync(skillPath, 'utf8'));
-                    if (this.validateSkill(skillData)) {
-                        this.skills.set(skillData.id, skillData);
-                        // Compile pattern for matching
-                        if (skillData.implementation.pattern) {
-                            this.skillPatterns.set(skillData.id, new RegExp(skillData.implementation.pattern, 'i'));
-                        }
-                    }
-                }
-                catch (error) {
-                    console.warn(`Failed to load skill from ${skillFile}:`, error);
-                }
-            }
-        }
-        catch (error) {
-            console.warn('Failed to scan skills directory:', error);
-        }
-    }
-    /**
-     * Validate skill structure
-     */
-    validateSkill(skill) {
-        return (typeof skill.id === 'string' &&
-            typeof skill.name === 'string' &&
-            typeof skill.description === 'string' &&
-            typeof skill.category === 'string' &&
-            Array.isArray(skill.tags) &&
-            Array.isArray(skill.examples) &&
-            skill.implementation &&
-            typeof skill.implementation.pattern === 'string');
-    }
-    /**
-     * Get all available skills
-     */
-    getAllSkills() {
-        return Array.from(this.skills.values());
-    }
-    /**
-     * Get skill by ID
-     */
-    getSkill(id) {
-        return this.skills.get(id);
-    }
-    /**
-     * Find skills by category
-     */
-    getSkillsByCategory(category) {
-        return this.getAllSkills().filter(skill => skill.category.toLowerCase() === category.toLowerCase());
-    }
-    /**
-     * Find skills by tag
-     */
-    getSkillsByTag(tag) {
-        return this.getAllSkills().filter(skill => skill.tags.some(t => t.toLowerCase() === tag.toLowerCase()));
-    }
-    /**
-     * Search skills by name or description
-     */
-    searchSkills(query) {
-        const lowerQuery = query.toLowerCase();
-        return this.getAllSkills().filter(skill => skill.name.toLowerCase().includes(lowerQuery) ||
-            skill.description.toLowerCase().includes(lowerQuery) ||
-            skill.tags.some(tag => tag.toLowerCase().includes(lowerQuery)));
-    }
-    /**
-     * Match input against skill patterns
-     */
-    matchSkills(input) {
-        const matches = [];
-        for (const [skillId, pattern] of this.skillPatterns) {
-            const skill = this.skills.get(skillId);
-            if (!skill)
-                continue;
-            const match = pattern.exec(input);
-            if (match) {
-                // Calculate confidence based on match length and input length
-                const confidence = Math.min(match[0].length / input.length, 1);
-                matches.push({ skill, confidence });
-            }
-        }
-        // Sort by confidence (descending)
-        return matches.sort((a, b) => b.confidence - a.confidence);
-    }
-    /**
-     * Execute a skill
-     */
-    async executeSkill(skillId, input) {
-        const startTime = Date.now();
-        try {
-            const skill = this.getSkill(skillId);
-            if (!skill) {
-                return {
-                    success: false,
-                    error: `Skill not found: ${skillId}`,
-                    duration: Date.now() - startTime
-                };
-            }
-            let output = input;
-            // Apply transformation if defined
-            if (skill.implementation.transform) {
-                // In a real implementation, this would execute the transformation
-                // For now, we'll return a placeholder
-                output = `[Transformed by ${skill.name}] ${JSON.stringify(input)}`;
-            }
-            // Apply template if defined
-            if (skill.implementation.template) {
-                output = skill.implementation.template.replace('{{input}}', JSON.stringify(input));
-            }
-            return {
-                success: true,
-                output,
-                duration: Date.now() - startTime
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-                duration: Date.now() - startTime
-            };
-        }
-    }
-    /**
-     * Get skill statistics
-     */
-    getStatistics() {
-        const skills = this.getAllSkills();
-        const categories = new Set(skills.map(s => s.category));
-        const tags = new Set(skills.flatMap(s => s.tags));
-        return {
-            totalSkills: skills.length,
-            totalCategories: categories.size,
-            totalTags: tags.size,
-            categories: Array.from(categories),
-            mostCommonTags: this.getMostCommonTags()
-        };
-    }
-    /**
-     * Get most common tags
-     */
-    getMostCommonTags() {
-        const tagCounts = new Map();
-        for (const skill of this.getAllSkills()) {
-            for (const tag of skill.tags) {
-                tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
-            }
-        }
-        return Array.from(tagCounts.entries())
-            .map(([tag, count]) => ({ tag, count }))
-            .sort((a, b) => b.count - a.count)
-            .slice(0, 10);
-    }
-    // Compatibility methods for existing tools
-    listSkills() {
-        return this.getAllSkills().map(skill => ({
-            id: skill.id,
-            name: skill.name,
-            description: skill.description,
-            category: skill.category,
-            tags: skill.tags
-        }));
-    }
-    refresh() {
-        // Clear and reload skills
-        this.skills.clear();
-        this.skillPatterns.clear();
-        this.loadBuiltInSkills();
-    }
-}
-// ============================================================================
-// Default Instance
-// ============================================================================
-export const skillRepository = new SkillRepository();

package/dist/bin/skills/types.js

@@ -1 +0,0 @@
-export {};

package/dist/bin/subagents/taskRunner.js

@@ -1,269 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { createNodeRuntime } from '../runtime/node.js';
-import { loadToolSettings } from '../core/preferences.js';
-import { buildEnabledToolSet, evaluateToolPermissions } from '../capabilities/toolRegistry.js';
-const SUBAGENT_DEFINITIONS = {
-    'general-purpose': {
-        id: 'general-purpose',
-        label: 'General Purpose',
-        summary: 'complete research, editing, and implementation tasks end-to-end',
-        instructions: [
-            'Own the entire task autonomously. Narrate your plan, gather context with filesystem/search tools, and make changes when necessary.',
-            'Always cite the evidence, commands, and files you touched. Include TODOs or risks that need human review.',
-        ],
-        defaultModel: 'sonnet',
-    },
-    explore: {
-        id: 'explore',
-        label: 'Explore',
-        summary: 'map the codebase, answer architectural questions, and locate patterns quickly',
-        instructions: [
-            'Prioritize read/search/glob tools before editing. Call out every directory or file you investigated.',
-            'Return a crisp summary of what you learned plus direct file references so the parent agent can follow up.',
-        ],
-        defaultModel: 'haiku',
-    },
-    plan: {
-        id: 'plan',
-        label: 'Plan',
-        summary: 'break down complex efforts into actionable steps and identify risks or dependencies',
-        instructions: [
-            'Produce a numbered plan with estimates, dependency notes, and explicit testing checkpoints.',
-            'If the task mentions code changes, suggest which files/modules should be edited and why before any implementation occurs.',
-        ],
-        defaultModel: 'sonnet',
-    },
-};
-const MODEL_ID_LOOKUP = {
-    sonnet: { provider: 'anthropic', model: 'claude-sonnet-4-5-20250929' },
-    opus: { provider: 'anthropic', model: 'claude-opus-4.1' },
-    haiku: { provider: 'anthropic', model: 'claude-haiku-4.5' },
-};
-const TASK_STORE_DIR = join(homedir(), '.erosolar', 'tasks');
-export class TaskRunner {
-    constructor(context) {
-        this.snapshots = new TaskSnapshotStore();
-        this.context = context;
-    }
-    async runTask(options) {
-        const definition = resolveSubAgentDefinition(options.subagentType);
-        const { allowedPluginIds } = this.resolveToolPermissions();
-        const adapterOptions = allowedPluginIds.size
-            ? {
-                filter: (plugin) => allowedPluginIds.has(plugin.id),
-            }
-            : undefined;
-        const runtime = await createNodeRuntime({
-            profile: this.context.profile,
-            workspaceContext: this.context.workspaceContext,
-            workingDir: this.context.workingDir,
-            env: this.context.env,
-            adapterOptions,
-        });
-        try {
-            const session = runtime.session;
-            const selection = this.buildModelSelection(session.profileConfig, options.model ?? definition.defaultModel);
-            const systemPrompt = this.composeSystemPrompt(session.profileConfig.systemPrompt, definition, options.description);
-            let finalMetadata = null;
-            const agent = session.createAgent({
-                provider: selection.provider,
-                model: selection.model,
-                temperature: selection.temperature,
-                maxTokens: selection.maxTokens,
-                systemPrompt,
-            }, {
-                onAssistantMessage: (_content, metadata) => {
-                    if (metadata.isFinal) {
-                        finalMetadata = metadata;
-                    }
-                },
-            });
-            const resumeSnapshot = options.resumeId ? await this.snapshots.load(options.resumeId) : null;
-            if (options.resumeId && !resumeSnapshot) {
-                throw new Error(`Resume id "${options.resumeId}" was not found. Call Task without resume to start a new agent.`);
-            }
-            if (resumeSnapshot) {
-                agent.loadHistory(resumeSnapshot.history);
-            }
-            const startedAt = Date.now();
-            const reply = await agent.send(options.prompt, false);
-            const durationMs = Date.now() - startedAt;
-            const history = agent.getHistory();
-            const resumeId = options.resumeId ?? this.snapshots.createId();
-            await this.snapshots.save({
-                id: resumeId,
-                profile: this.context.profile,
-                description: options.description,
-                subagentType: definition.id,
-                history,
-                createdAt: resumeSnapshot?.createdAt ?? new Date().toISOString(),
-                updatedAt: new Date().toISOString(),
-            });
-            const parsed = extractResponseSections(reply);
-            const usageLine = formatUsage(extractUsage(finalMetadata));
-            const durationLine = `Duration: ${formatDuration(durationMs)}${usageLine ? ` | ${usageLine}` : ''}`;
-            const lines = [
-                `Task "${options.description}" completed by ${definition.label} agent (${selection.model})`,
-                `${durationLine} | Resume ID: ${resumeId}`,
-            ];
-            if (definition.summary) {
-                lines.push(`Agent focus: ${definition.summary}`);
-            }
-            if (parsed.thinking) {
-                lines.push('', 'Key reasoning:', parsed.thinking);
-            }
-            lines.push('', parsed.response || '(no response returned)');
-            return { output: lines.join('\n').trim() };
-        }
-        finally {
-            await runtime.host.dispose();
-        }
-    }
-    resolveToolPermissions() {
-        const settings = loadToolSettings();
-        const selection = buildEnabledToolSet(settings);
-        const summary = evaluateToolPermissions(selection);
-        return {
-            allowedPluginIds: summary.allowedPluginIds,
-        };
-    }
-    buildModelSelection(profile, preferred) {
-        if (preferred && MODEL_ID_LOOKUP[preferred]) {
-            const mapping = MODEL_ID_LOOKUP[preferred];
-            return {
-                provider: mapping.provider,
-                model: mapping.model,
-                temperature: profile.temperature,
-                maxTokens: profile.maxTokens,
-            };
-        }
-        return {
-            provider: profile.provider,
-            model: profile.model,
-            temperature: profile.temperature,
-            maxTokens: profile.maxTokens,
-        };
-    }
-    composeSystemPrompt(basePrompt, definition, description) {
-        const lines = [
-            basePrompt.trim(),
-            '',
-            'You are an autonomous sub-agent launched via the Task tool. Operate independently and return a single comprehensive report to the parent agent.',
-            `Task summary: ${description}`,
-            `Agent specialization: ${definition.summary}`,
-            '',
-            'Execution rules:',
-            ...definition.instructions.map((line, index) => `${index + 1}. ${line}`),
-            '',
-            'When you finish:',
-            '- Provide a concise summary with actionable next steps.',
-            '- Mention any remaining risks, TODOs, or follow-ups.',
-            '- Include file paths, commands, or test names you touched so the operator can verify your work.',
-        ];
-        return lines.join('\n').trim();
-    }
-}
-class TaskSnapshotStore {
-    async load(id) {
-        try {
-            const file = join(TASK_STORE_DIR, `${sanitizeId(id)}.json`);
-            const content = await readFile(file, 'utf8');
-            const parsed = JSON.parse(content);
-            if (!parsed || typeof parsed !== 'object') {
-                return null;
-            }
-            return parsed;
-        }
-        catch {
-            return null;
-        }
-    }
-    async save(snapshot) {
-        await mkdir(TASK_STORE_DIR, { recursive: true });
-        const normalized = {
-            ...snapshot,
-            history: snapshot.history ?? [],
-            createdAt: snapshot.createdAt,
-            updatedAt: snapshot.updatedAt,
-        };
-        const file = join(TASK_STORE_DIR, `${sanitizeId(snapshot.id)}.json`);
-        await writeFile(file, JSON.stringify(normalized, null, 2), 'utf8');
-    }
-    createId() {
-        return `task_${randomUUID()}`;
-    }
-}
-function resolveSubAgentDefinition(name) {
-    const normalized = name ? name.trim().toLowerCase() : '';
-    const candidate = normalized ? SUBAGENT_DEFINITIONS[normalized] : undefined;
-    if (candidate) {
-        return candidate;
-    }
-    const fallback = SUBAGENT_DEFINITIONS['general-purpose'];
-    if (!fallback) {
-        throw new Error('General-purpose subagent definition is missing.');
-    }
-    return fallback;
-}
-function sanitizeId(value) {
-    return value.replace(/[^a-zA-Z0-9_-]/g, '').slice(0, 64) || 'task';
-}
-function extractResponseSections(content) {
-    if (!content) {
-        return { thinking: null, response: '' };
-    }
-    const thinkingMatch = /<thinking>([\s\S]*?)<\/thinking>/i.exec(content);
-    const responseMatch = /<response>([\s\S]*?)<\/response>/i.exec(content);
-    const thinking = thinkingMatch?.[1]?.trim() ?? null;
-    if (responseMatch?.[1]) {
-        return {
-            thinking,
-            response: responseMatch[1].trim(),
-        };
-    }
-    if (thinkingMatch?.[0]) {
-        const remaining = content.replace(thinkingMatch[0], '').trim();
-        return {
-            thinking,
-            response: remaining,
-        };
-    }
-    return { thinking: null, response: content.trim() };
-}
-function formatDuration(ms) {
-    if (!Number.isFinite(ms)) {
-        return 'unknown duration';
-    }
-    if (ms < 1000) {
-        return `${ms}ms`;
-    }
-    const seconds = ms / 1000;
-    if (seconds < 60) {
-        return `${seconds.toFixed(1)}s`;
-    }
-    const minutes = Math.floor(seconds / 60);
-    const remaining = Math.round(seconds % 60);
-    return `${minutes}m ${remaining}s`;
-}
-function extractUsage(metadata) {
-    return metadata?.usage ?? null;
-}
-function formatUsage(usage) {
-    if (!usage) {
-        return '';
-    }
-    const parts = [];
-    if (typeof usage.inputTokens === 'number') {
-        parts.push(`in ${usage.inputTokens}`);
-    }
-    if (typeof usage.outputTokens === 'number') {
-        parts.push(`out ${usage.outputTokens}`);
-    }
-    if (!parts.length && typeof usage.totalTokens === 'number') {
-        parts.push(`total ${usage.totalTokens}`);
-    }
-    return parts.length ? `Tokens ${parts.join(' / ')}` : '';
-}