micro-models-agent 0.19.0 → 0.19.2

package/dist/llm/orchestrator.js

@@ -1,194 +0,0 @@
-import { OpenAICompatProvider } from './openai-compat';
-import { jsonrepair } from 'jsonrepair';
-const PLAN_SYSTEM_PROMPT = `You are a planning assistant for an agent system with multiple expert sub-agents.
-Break down the user's task into subtasks that can be executed by different expert agents.
-
-Available experts and their tool tags:
-- code: file operations, code editing, shell commands
-- research: web search, web fetch, web browse, history search
-- browser: browser automation, screenshots
-- vision: browser + file reading for visual tasks
-
-Rules:
-1. Each subtask must have an expert_tag from the available experts.
-2. Use depends_on for ordering when subtask B reads what subtask A writes.
-3. Independent subtasks should NOT depend on each other (they run in parallel).
-4. allowed_files is for files the subtask will CREATE or MODIFY.
-5. read_only_files is for files the subtask needs to READ only.
-6. File paths should be relative to the workspace root.
-7. Do NOT use keyword matching to determine task type. Instead, analyze the actual nature of the task.
-
-Respond with a JSON object only (no markdown fences):
-{
-  "title": "Plan title",
-  "subtasks": [
-    {
-      "id": "task-1",
-      "description": "Clear description",
-      "expert_tag": "code",
-      "allowed_files": ["src/file.ts"],
-      "read_only_files": [],
-      "depends_on": [],
-      "input_from": [],
-      "expected_output": "What this subtask produces",
-      "success_criteria": ["criterion 1", "criterion 2"]
-    }
-  ],
-  "shared_context": {
-    "rules": ["rule 1"],
-    "refs": []
-  }
-}`;
-const VERIFY_SYSTEM_PROMPT = `You are a verification and merge assistant for an agent system with multiple expert sub-agents.
-You receive the original plan, the results from each subtask, and any verification errors.
-Your job is to determine if the overall task was completed successfully or if re-planning is needed.
-
-Respond with JSON only:
-- If successful: {"type": "final", "finalAnswer": "summary of results", "explanation": "details"}
-- If re-plan needed: {"type": "replan", "plan": {updated MoEPlan}, "explanation": "why re-plan is needed"}
-
-Max 3 re-plan cycles. After 3 cycles, return partial result.`;
-export class OrchestratorClient {
-    config;
-    provider = null;
-    replanCycle = 0;
-    constructor(config, defaultProvider) {
-        this.config = config;
-        if (config.model) {
-            if (config.provider) {
-                this.provider = new OpenAICompatProvider({
-                    model: config.model,
-                    baseUrl: config.provider.baseUrl || 'http://localhost:1234/v1',
-                    apiKey: config.provider.apiKey,
-                    retry: config.retry,
-                });
-            }
-            else if (defaultProvider) {
-                this.provider = defaultProvider;
-            }
-            else {
-                this.provider = new OpenAICompatProvider({
-                    model: config.model,
-                    baseUrl: 'http://localhost:1234/v1',
-                    retry: config.retry,
-                });
-            }
-        }
-    }
-    isEnabled() {
-        return this.provider !== null;
-    }
-    getReplanCycle() {
-        return this.replanCycle;
-    }
-    async chat(messages) {
-        if (!this.provider)
-            throw new Error('Orchestrator not enabled');
-        const chunks = [];
-        for await (const chunk of this.provider.chat(messages)) {
-            chunks.push(chunk);
-        }
-        return chunks
-            .filter((c) => c.type === 'text')
-            .map((c) => c.content)
-            .join('');
-    }
-    parseJSON(text) {
-        try {
-            return JSON.parse(text);
-        }
-        catch {
-            try {
-                const repaired = jsonrepair(text);
-                return JSON.parse(repaired);
-            }
-            catch {
-                const jsonMatch = text.match(/\{[\s\S]*\}/);
-                if (jsonMatch) {
-                    try {
-                        const repaired = jsonrepair(jsonMatch[0]);
-                        return JSON.parse(repaired);
-                    }
-                    catch { /* fall through */ }
-                }
-                return null;
-            }
-        }
-    }
-    async plan(userPrompt, _context) {
-        if (!this.provider)
-            return { error: 'Orchestrator not enabled — no orchestrator model configured' };
-        const messages = [
-            { role: 'system', content: PLAN_SYSTEM_PROMPT },
-            { role: 'user', content: userPrompt },
-        ];
-        const text = await this.chat(messages);
-        const parsed = this.parseJSON(text);
-        if (parsed && parsed.subtasks && parsed.subtasks.length > 0) {
-            return { plan: parsed, raw: text };
-        }
-        return { error: `Failed to parse plan from LLM output. Raw: ${text.slice(0, 500)}` };
-    }
-    async verifyAndMerge(input) {
-        if (!this.provider)
-            return { type: 'final', finalAnswer: input.results.map(r => r.summary).join('\n') };
-        this.replanCycle++;
-        if (this.replanCycle > 3) {
-            return {
-                type: 'final',
-                finalAnswer: input.results.map(r => `${r.subtaskId}: ${r.success ? 'OK' : 'FAIL'} — ${r.summary}`).join('\n'),
-                explanation: 'Max re-plan cycles (3) reached. Returning partial results.',
-            };
-        }
-        const context = JSON.stringify(input, null, 2);
-        const messages = [
-            { role: 'system', content: VERIFY_SYSTEM_PROMPT },
-            { role: 'user', content: context },
-        ];
-        const text = await this.chat(messages);
-        const parsed = this.parseJSON(text);
-        if (parsed && parsed.type) {
-            return parsed;
-        }
-        return {
-            type: 'final',
-            finalAnswer: input.results.map(r => r.summary).join('\n'),
-            explanation: 'Failed to parse verifier output, returning collected results.',
-        };
-    }
-    async createPlan(task) {
-        if (!this.provider)
-            throw new Error('Orchestrator not enabled');
-        const messages = [
-            {
-                role: 'system',
-                content: 'You are a planning assistant. Break down tasks into steps. Respond with JSON only: {"steps": ["step 1", "step 2", ...]}',
-            },
-            { role: 'user', content: task },
-        ];
-        const text = await this.chat(messages);
-        try {
-            return JSON.parse(text);
-        }
-        catch {
-            return { steps: [task] };
-        }
-    }
-    async resolveConflict(context) {
-        if (!this.provider)
-            throw new Error('Orchestrator not enabled');
-        const messages = [
-            {
-                role: 'system',
-                content: 'You are a conflict resolution assistant. Analyze the situation and recommend the best path forward.',
-            },
-            { role: 'user', content: context },
-        ];
-        let result = '';
-        for await (const chunk of this.provider.chat(messages)) {
-            if (chunk.type === 'text' && chunk.content)
-                result += chunk.content;
-        }
-        return result;
-    }
-}

package/dist/llm/provider.js

@@ -1,10 +0,0 @@
-// src/llm/provider.ts
-/** Helper: extract plain text from message content (for token counting, logging, etc.) */
-export function getMessageText(content) {
-    if (typeof content === "string")
-        return content;
-    return content
-        .filter((p) => p.type === "text")
-        .map((p) => p.text)
-        .join("");
-}

package/dist/llm/response.js

@@ -1,39 +0,0 @@
-export function parseChunks(chunks) {
-    let text = '';
-    let reasoning;
-    const toolCalls = [];
-    let hasToolCalls = false;
-    for (const chunk of chunks) {
-        if (chunk.type === 'text' && chunk.content) {
-            text += chunk.content;
-        }
-        if (chunk.type === 'reasoning' && chunk.content) {
-            reasoning = (reasoning || '') + chunk.content;
-        }
-        if (chunk.type === 'tool_call' && chunk.toolCall) {
-            hasToolCalls = true;
-            let parsedArgs;
-            try {
-                parsedArgs = JSON.parse(chunk.toolCall.arguments);
-            }
-            catch {
-                parsedArgs = {};
-            }
-            toolCalls.push({
-                id: chunk.toolCall.id,
-                name: chunk.toolCall.name,
-                arguments: parsedArgs,
-            });
-        }
-    }
-    if (hasToolCalls) {
-        return { type: 'tool_call', calls: toolCalls, reasoning };
-    }
-    if (reasoning && !text) {
-        return { type: 'reasoning', content: reasoning };
-    }
-    if (!text && !reasoning) {
-        return { type: 'empty' };
-    }
-    return { type: 'text', content: text || '', reasoning };
-}

package/dist/llm/token-counter.js

@@ -1,39 +0,0 @@
-// src/llm/token-counter.ts
-import { encodingForModel, getEncoding } from "js-tiktoken";
-import { getMessageText } from "./provider";
-export class TokenCounter {
-    encoder;
-    constructor(model = "gpt-4o") {
-        try {
-            this.encoder = encodingForModel(model);
-        }
-        catch {
-            // Fallback to cl100k_base for unknown models
-            this.encoder = getEncoding("cl100k_base");
-        }
-    }
-    count(text) {
-        if (!text)
-            return 0;
-        return this.encoder.encode(text).length;
-    }
-    countMessages(messages) {
-        let total = 0;
-        for (const msg of messages) {
-            // ~4 tokens per message overhead (role, boundaries)
-            total += 4;
-            const text = getMessageText(msg.content);
-            total += this.count(text);
-            if (msg.role === "tool")
-                total += 2; // tool_call_id
-        }
-        total += 2; // assistant priming
-        return total;
-    }
-    encode(text) {
-        return this.encoder.encode(text);
-    }
-    decode(tokens) {
-        return this.encoder.decode(tokens);
-    }
-}

package/dist/llm/types.js

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

package/dist/logger/app-logger.js

@@ -1,76 +0,0 @@
-import { appendFileSync, mkdirSync, existsSync } from 'fs';
-import { join } from 'path';
-import { sanitizeLogMessage } from '../modules/security/data-sanitizer';
-const LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
-export class Logger {
-    level;
-    prefix;
-    logDir = null;
-    constructor(level = 'info', prefix = '') {
-        this.level = level;
-        this.prefix = prefix;
-    }
-    setLevel(level) {
-        this.level = level;
-    }
-    setLogDir(dir) {
-        this.logDir = dir;
-        if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true });
-        }
-    }
-    child(prefix) {
-        const childLogger = new Logger(this.level, this.prefix ? `${this.prefix}:${prefix}` : prefix);
-        if (this.logDir)
-            childLogger.setLogDir(this.logDir);
-        return childLogger;
-    }
-    debug(msg, meta) {
-        this.log('debug', msg, meta);
-    }
-    info(msg, meta) {
-        this.log('info', msg, meta);
-    }
-    warn(msg, meta) {
-        this.log('warn', msg, meta);
-    }
-    error(msg, meta) {
-        this.log('error', msg, meta);
-    }
-    log(level, msg, meta) {
-        if (LEVELS[level] < LEVELS[this.level])
-            return;
-        // Sanitize log message to remove sensitive data
-        const sanitizedMsg = sanitizeLogMessage(msg);
-        const sanitizedMeta = meta ? this.sanitizeMeta(meta) : undefined;
-        const ts = new Date().toISOString();
-        const prefix = this.prefix ? ` [${this.prefix}]` : '';
-        const metaStr = sanitizedMeta ? ` ${JSON.stringify(sanitizedMeta)}` : '';
-        const line = `[${level.toUpperCase()}]${prefix} ${ts} — ${sanitizedMsg}${metaStr}`;
-        console.log(line);
-        if (this.logDir) {
-            try {
-                appendFileSync(join(this.logDir, 'app.jsonl'), JSON.stringify({ level, ts, prefix: this.prefix, msg: sanitizedMsg, meta: sanitizedMeta ?? null }) + '\n', 'utf-8');
-            }
-            catch { /* file logging is best-effort */ }
-        }
-    }
-    /**
-     * Sanitize metadata object to remove sensitive data
-     */
-    sanitizeMeta(meta) {
-        const sanitized = {};
-        for (const [key, value] of Object.entries(meta)) {
-            if (typeof value === 'string') {
-                sanitized[key] = sanitizeLogMessage(value);
-            }
-            else if (typeof value === 'object' && value !== null) {
-                sanitized[key] = this.sanitizeMeta(value);
-            }
-            else {
-                sanitized[key] = value;
-            }
-        }
-        return sanitized;
-    }
-}

package/dist/logger/index.js

@@ -1 +0,0 @@
-export { Logger } from './app-logger';

package/dist/migration/backup.js

@@ -1,45 +0,0 @@
-import { copyFileSync, cpSync, existsSync, mkdirSync, readdirSync, writeFileSync } from 'fs';
-import { join } from 'path';
-import { t } from '../i18n/index';
-export class BackupManager {
-    configDir;
-    constructor(configDir) {
-        this.configDir = configDir;
-    }
-    backupConfig() {
-        const configPath = join(this.configDir, 'config.json');
-        if (!existsSync(configPath))
-            return;
-        const bakPath = join(this.configDir, 'config.json.bak');
-        copyFileSync(configPath, bakPath);
-    }
-    backupAll() {
-        const bakDir = this.configDir + '.bak';
-        if (existsSync(bakDir))
-            return;
-        if (existsSync(this.configDir)) {
-            cpSync(this.configDir, bakDir, { recursive: true });
-        }
-    }
-    writeFreshConfig(config) {
-        if (!existsSync(this.configDir)) {
-            mkdirSync(this.configDir, { recursive: true });
-        }
-        writeFileSync(join(this.configDir, 'config.json'), JSON.stringify(config, null, 2), 'utf-8');
-    }
-    getBackupSummary() {
-        const lines = [];
-        const bakConfig = join(this.configDir, 'config.json.bak');
-        const bakDir = this.configDir + '.bak';
-        if (existsSync(bakConfig)) {
-            lines.push(t('migration.config_bak'));
-        }
-        if (existsSync(bakDir)) {
-            const files = readdirSync(bakDir);
-            lines.push(t('migration.dir_bak', { count: files.length }));
-        }
-        return lines.length > 0
-            ? `${t('migration.migrated')}\n${lines.join('\n')}`
-            : t('migration.not_needed');
-    }
-}

package/dist/migration/detect.js

@@ -1,50 +0,0 @@
-import { existsSync, readFileSync, readdirSync } from 'fs';
-import { join } from 'path';
-const V1_ONLY_FIELDS = ['apiBase', 'apiKey', 'chatEndpoint', 'temperature', 'maxTokens'];
-export class MigrationDetector {
-    configDir;
-    constructor(configDir) {
-        this.configDir = configDir;
-    }
-    needsMigration() {
-        const configPath = join(this.configDir, 'config.json');
-        if (!existsSync(configPath))
-            return false;
-        try {
-            const content = readFileSync(configPath, 'utf-8');
-            const config = JSON.parse(content);
-            if (config.version && config.version.startsWith('2.'))
-                return false;
-            for (const field of V1_ONLY_FIELDS) {
-                if (field in config)
-                    return true;
-            }
-            const v2Required = ['provider', 'contextWindow', 'contextBudget'];
-            const hasAllV2Fields = v2Required.every(f => f in config);
-            if (!hasAllV2Fields)
-                return true;
-            return false;
-        }
-        catch {
-            return true;
-        }
-    }
-    hasOldSessions() {
-        const sessionsDir = join(this.configDir, 'sessions');
-        if (!existsSync(sessionsDir))
-            return false;
-        return readdirSync(sessionsDir).length > 0;
-    }
-    hasOldProfile() {
-        const profilePath = join(this.configDir, 'profile.json');
-        if (!existsSync(profilePath))
-            return false;
-        try {
-            const profile = JSON.parse(readFileSync(profilePath, 'utf-8'));
-            return !profile.platform && !profile.os;
-        }
-        catch {
-            return false;
-        }
-    }
-}

package/dist/migration/index.js

@@ -1,2 +0,0 @@
-export { MigrationDetector } from './detect';
-export { BackupManager } from './backup';

package/dist/modules/browser/actions.js

@@ -1,46 +0,0 @@
-export function buildClickScript(elementIndex) {
-    return `
-    const el = document.querySelector('[data-browser-index="${elementIndex}"]');
-    if (!el) throw new Error('Element not found: ${elementIndex}');
-    el.click();
-  `;
-}
-export function buildTypeScript(elementIndex, text) {
-    const escaped = JSON.stringify(text);
-    return `
-    const el = document.querySelector('[data-browser-index="${elementIndex}"]');
-    if (!el) throw new Error('Element not found: ${elementIndex}');
-    const text = JSON.parse(${JSON.stringify(escaped)});
-    el.focus();
-    el.value = text;
-    el.dispatchEvent(new Event('input', { bubbles: true }));
-    el.dispatchEvent(new Event('change', { bubbles: true }));
-  `;
-}
-export function buildScrollScript(direction) {
-    switch (direction) {
-        case 'down':
-            return `window.scrollBy({ top: 600, behavior: 'smooth' })`;
-        case 'up':
-            return `window.scrollBy({ top: -600, behavior: 'smooth' })`;
-        case 'top':
-            return `window.scrollTo({ top: 0, behavior: 'smooth' })`;
-        case 'bottom':
-            return `window.scrollTo({ top: document.body.scrollHeight, behavior: 'smooth' })`;
-    }
-}
-export function buildWaitScript(timeoutMs) {
-    return `await new Promise(r => setTimeout(r, ${timeoutMs}))`;
-}
-export function buildIndexInjectionScript() {
-    return `
-    const selectors = 'a[href], button, input, textarea, select, [role="button"], [role="link"], [role="textbox"], [role="checkbox"], [role="radio"], [contenteditable="true"]';
-    const elements = document.querySelectorAll(selectors);
-    let idx = 1;
-    elements.forEach(el => {
-      const style = window.getComputedStyle(el);
-      if (style.display === 'none' || style.visibility === 'hidden') return;
-      el.setAttribute('data-browser-index', String(idx++));
-    });
-  `;
-}

package/dist/modules/browser/cookie-store.js

@@ -1,24 +0,0 @@
-import { readFile, writeFile, mkdir } from 'fs/promises';
-import { join } from 'path';
-export class CookieStore {
-    filePath;
-    constructor(cookieDir) {
-        this.filePath = join(cookieDir, 'cookies.json');
-    }
-    async save(cookies) {
-        await mkdir(join(this.filePath, '..'), { recursive: true });
-        await writeFile(this.filePath, JSON.stringify(cookies, null, 2), 'utf-8');
-    }
-    async load() {
-        try {
-            const data = await readFile(this.filePath, 'utf-8');
-            return JSON.parse(data);
-        }
-        catch {
-            return [];
-        }
-    }
-    async clear() {
-        await this.save([]);
-    }
-}

package/dist/modules/browser/index.js

@@ -1,5 +0,0 @@
-export { BrowserModule } from './module';
-export { BrowserSession, BrowserActionTracker } from './session';
-export { CookieStore } from './cookie-store';
-export { extractInteractiveElements, formatSnapshot } from './snapshot';
-export { DEFAULT_BROWSER_CONFIG } from './types';

package/dist/modules/browser/module.js

@@ -1,28 +0,0 @@
-import { createBrowserTool, closeBrowserSession } from '../../tools/browser';
-export class BrowserModule {
-    name = 'browser';
-    getSystemPromptBlock() {
-        return {
-            content: [
-                'You have a headless browser tool. Use it to navigate websites, click links, fill forms, and read page content.',
-                'Workflow: open(url) → read snapshot → click/type on element numbers → read updated snapshot.',
-                'Always start with "open" action. Use element numbers from snapshot for click/type targets.',
-                'Use "screenshot" action only if the model supports vision. Otherwise rely on the text snapshot.',
-            ].join('\n'),
-            priority: 'normal',
-            essential: false,
-            estimatedTokens: 80,
-        };
-    }
-    getToolDefinitions() {
-        return [createBrowserTool()];
-    }
-    getPlugin() {
-        return {
-            name: 'browser',
-            onSessionEnd: () => {
-                closeBrowserSession();
-            },
-        };
-    }
-}