@openlife/cli 1.7.3

package/dist/orchestrator/Brain.js

@@ -0,0 +1,298 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Brain = void 0;
+const child_process = __importStar(require("child_process"));
+const util_1 = require("util");
+const openai_1 = __importDefault(require("openai"));
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const generative_ai_1 = require("@google/generative-ai");
+const ModelManager_1 = require("./ModelManager");
+const ToolsetGuard_1 = require("./toolset/ToolsetGuard");
+const execFile = (0, util_1.promisify)(child_process.execFile);
+const DEFAULT_MODEL_TIMEOUT_MS = Number(process.env.OPENLIFE_MODEL_TIMEOUT_MS || 120000);
+const REASONING_MODE = String(process.env.OPENLIFE_REASONING_MODE || 'errors').toLowerCase(); // off | errors | always
+class Brain {
+    openai = null;
+    anthropic = null;
+    geminiApi = null;
+    modelManager;
+    constructor() {
+        this.modelManager = new ModelManager_1.ModelManager();
+        const openAIKey = process.env.OPENAI_API_KEY;
+        if (openAIKey && openAIKey.trim() !== '') {
+            const opts = { apiKey: openAIKey };
+            const openAIBaseUrl = (process.env.OPENAI_BASE_URL || '').trim();
+            if (openAIBaseUrl)
+                opts.baseURL = openAIBaseUrl;
+            this.openai = new openai_1.default(opts);
+        }
+        const anthropicKey = process.env.ANTHROPIC_API_KEY;
+        if (anthropicKey && anthropicKey.trim() !== '')
+            this.anthropic = new sdk_1.default({ apiKey: anthropicKey });
+        const geminiKey = process.env.GEMINI_API_KEY;
+        if (geminiKey && geminiKey.trim() !== '')
+            this.geminiApi = new generative_ai_1.GoogleGenerativeAI(geminiKey);
+    }
+    /**
+     * Story 8.1 — public probe for v1.4 creators.
+     *
+     * Returns true iff at least one API-key-backed provider is configured
+     * (OpenAI, Anthropic, Gemini, OpenRouter, or Ollama URL). Used by
+     * SquadCreator.design() / SkillCreator.design() to decide between
+     * LLM-driven proposal and heuristic fallback without forcing the
+     * caller to know about the provider table.
+     */
+    isAnyProviderAvailable() {
+        if (this.openai || this.anthropic || this.geminiApi)
+            return true;
+        if ((process.env.OPENROUTER_API_KEY || '').trim() !== '')
+            return true;
+        if ((process.env.OLLAMA_URL || '').trim() !== '')
+            return true;
+        return false;
+    }
+    async think(systemPrompt, userMessage) {
+        const config = this.modelManager.getModelConfig();
+        const modelsToTry = [config.primary, ...config.fallbacks].filter((model, index, arr) => arr.findIndex(m => m.raw === model.raw) === index);
+        const failures = [];
+        for (let i = 0; i < modelsToTry.length; i++) {
+            const modelIdent = modelsToTry[i];
+            try {
+                console.log(`[BRAIN] Tentando modelo ${i === 0 ? 'PRIMÁRIO' : 'FALLBACK ' + i}: ${modelIdent.raw}...`);
+                let out = '';
+                switch (modelIdent.provider) {
+                    case 'openai-api':
+                        out = await this.thinkWithOpenAIAPI(systemPrompt, userMessage, modelIdent.name);
+                        break;
+                    case 'openai-cli':
+                        out = await this.thinkWithOpenAICLI(systemPrompt, userMessage, modelIdent.name);
+                        break;
+                    case 'anthropic':
+                        out = await this.thinkWithAnthropic(systemPrompt, userMessage, modelIdent.name);
+                        break;
+                    case 'gemini-api':
+                        out = await this.thinkWithGeminiAPI(systemPrompt, userMessage, modelIdent.name);
+                        break;
+                    case 'gemini-cli':
+                        out = await this.thinkWithGeminiCLI(systemPrompt, userMessage, modelIdent.name);
+                        break;
+                    case 'ollama':
+                        out = await this.thinkWithOllama(systemPrompt, userMessage, modelIdent.name);
+                        break;
+                    case 'openrouter':
+                        out = await this.thinkWithOpenRouter(systemPrompt, userMessage, modelIdent.name);
+                        break;
+                    default: throw new Error(`Provedor desconhecido: ${modelIdent.provider}`);
+                }
+                if (REASONING_MODE === 'always') {
+                    const trace = [
+                        `🔎 model_try: "${modelIdent.raw}"`,
+                        `🧭 fallback_chain: "${modelsToTry.length} candidatos"`,
+                        `✅ model_selected: "${modelIdent.raw}"`
+                    ].join('\n');
+                    return `${trace}\n\n${out}`;
+                }
+                return out;
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                failures.push({ model: modelIdent.raw, reason });
+                console.error(`[BRAIN ERROR - ${modelIdent.raw}]`, reason);
+                if (i !== modelsToTry.length - 1)
+                    console.log(`[BRAIN] Rotacionando para o próximo fallback da cadeia...`);
+            }
+        }
+        const concise = failures.slice(-3).map(f => `- ${f.model}: ${f.reason}`).join('\n');
+        const guidance = [
+            '1) Configure ao menos um provedor API no Railway (ex.: GEMINI_API_KEY ou OPENAI_API_KEY).',
+            '2) Não dependa de CLI providers (codex/gemini) no container sem binário/auth.',
+            '3) Rode: openlife doctor e valide a cadeia de modelos.'
+        ].join('\n');
+        const summary = REASONING_MODE !== 'off'
+            ? `\n\nResumo operacional:\n- Objetivo: responder com robustez por fallback.\n- Estratégia: rotação sequencial de provedores.\n- Resultado: todos os provedores tentados falharam.`
+            : '';
+        return `CRITICAL ERROR: cadeia de modelos indisponível no momento.\n\nFalhas recentes:\n${concise}\n\nAção recomendada:\n${guidance}${summary}`;
+    }
+    formatProviderError(provider, model, error, opts) {
+        const e = (error && typeof error === 'object' ? error : {});
+        const response = (e.response && typeof e.response === 'object' ? e.response : {});
+        const responseData = (response.data && typeof response.data === 'object' ? response.data : {});
+        const responseDataError = (responseData.error && typeof responseData.error === 'object' ? responseData.error : {});
+        const errorObj = (e.error && typeof e.error === 'object' ? e.error : {});
+        const parts = [];
+        const status = e.status ?? response.status ?? e.code;
+        if (status !== undefined && status !== null)
+            parts.push(`HTTP ${String(status)}`);
+        const apiMessage = (typeof errorObj.message === 'string' ? errorObj.message : undefined) ||
+            (typeof responseDataError.message === 'string' ? responseDataError.message : undefined) ||
+            (typeof e.message === 'string' ? e.message : undefined) ||
+            String(error);
+        parts.push(String(apiMessage || 'erro_desconhecido').slice(0, 240));
+        const stderr = typeof e.stderr === 'string' ? e.stderr.trim().slice(-200) : '';
+        if (stderr)
+            parts.push(`stderr: ${stderr}`);
+        if (opts?.keyEnvVar && opts?.expectedKeyPrefix) {
+            const rawKey = process.env[opts.keyEnvVar] || '';
+            if (rawKey && !rawKey.startsWith(opts.expectedKeyPrefix)) {
+                parts.push(`key prefix: ${rawKey.slice(0, 8)} (esperado começar com "${opts.expectedKeyPrefix}")`);
+            }
+        }
+        const wrapped = new Error(`[${provider}/${model}] ${parts.join(' | ')}`);
+        wrapped.cause = error;
+        wrapped.providerStatus = status;
+        return wrapped;
+    }
+    async thinkWithOpenAIAPI(systemPrompt, userMessage, model) {
+        if (!this.openai)
+            throw new Error('OPENAI_API_KEY não configurada no .env.');
+        try {
+            const response = await this.openai.chat.completions.create({
+                model,
+                messages: [{ role: 'system', content: systemPrompt }, { role: 'user', content: userMessage }],
+                temperature: 0.7,
+            });
+            return response.choices[0].message.content || 'Sem resposta.';
+        }
+        catch (err) {
+            throw this.formatProviderError('openai-api', model, err, { keyEnvVar: 'OPENAI_API_KEY', expectedKeyPrefix: 'sk-' });
+        }
+    }
+    async thinkWithOpenAICLI(systemPrompt, userMessage, model) {
+        (0, ToolsetGuard_1.assertToolsetAllowed)('delegation', 'Brain.thinkWithOpenAICLI');
+        const args = ['exec', '--dangerously-bypass-approvals-and-sandbox', '--skip-git-repo-check'];
+        if (model && model !== 'default')
+            args.push('--model', model);
+        args.push(`${systemPrompt}\n\nMensagem: ${userMessage}`);
+        try {
+            const { stdout } = await execFile('codex', args, { maxBuffer: 1024 * 1024 * 10, timeout: DEFAULT_MODEL_TIMEOUT_MS });
+            return stdout.trim() || 'Sem resposta do Codex CLI.';
+        }
+        catch (err) {
+            throw this.formatProviderError('openai-cli', model, err);
+        }
+    }
+    async thinkWithAnthropic(systemPrompt, userMessage, model) {
+        if (!this.anthropic)
+            throw new Error('ANTHROPIC_API_KEY não configurada no .env.');
+        try {
+            const response = await this.anthropic.messages.create({ model, max_tokens: 4096, system: systemPrompt, messages: [{ role: 'user', content: userMessage }] });
+            const first = response.content[0];
+            if (first && first.type === 'text')
+                return first.text || 'Sem resposta.';
+            return 'Sem resposta.';
+        }
+        catch (err) {
+            throw this.formatProviderError('anthropic', model, err, { keyEnvVar: 'ANTHROPIC_API_KEY', expectedKeyPrefix: 'sk-ant-' });
+        }
+    }
+    async thinkWithGeminiAPI(systemPrompt, userMessage, model) {
+        if (!this.geminiApi)
+            throw new Error('GEMINI_API_KEY não configurada no .env.');
+        try {
+            const generativeModel = this.geminiApi.getGenerativeModel({ model, systemInstruction: systemPrompt });
+            const result = await generativeModel.generateContent(userMessage);
+            const response = await result.response;
+            return response.text();
+        }
+        catch (err) {
+            throw this.formatProviderError('gemini-api', model, err);
+        }
+    }
+    async thinkWithOpenRouter(systemPrompt, userMessage, model) {
+        const apiKey = process.env.OPENROUTER_API_KEY;
+        if (!apiKey)
+            throw new Error('OPENROUTER_API_KEY não configurada no .env.');
+        const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+            body: JSON.stringify({ model, messages: [{ role: 'system', content: systemPrompt }, { role: 'user', content: userMessage }] })
+        });
+        if (!response.ok) {
+            const bodyText = await response.text().catch(() => '');
+            throw this.formatProviderError('openrouter', model, { status: response.status, message: response.statusText, error: { message: bodyText.slice(0, 200) } });
+        }
+        try {
+            const data = (await response.json());
+            return data.choices?.[0]?.message?.content || 'Sem resposta.';
+        }
+        catch (err) {
+            throw this.formatProviderError('openrouter', model, err);
+        }
+    }
+    async thinkWithOllama(systemPrompt, userMessage, model) {
+        const url = process.env.OLLAMA_URL || 'http://localhost:11434/api/chat';
+        let response;
+        try {
+            response = await fetch(url, {
+                method: 'POST', headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ model, messages: [{ role: 'system', content: systemPrompt }, { role: 'user', content: userMessage }], stream: false })
+            });
+        }
+        catch (err) {
+            throw this.formatProviderError('ollama', model, err);
+        }
+        if (!response.ok) {
+            const bodyText = await response.text().catch(() => '');
+            throw this.formatProviderError('ollama', model, { status: response.status, message: response.statusText, error: { message: bodyText.slice(0, 200) } });
+        }
+        try {
+            const data = (await response.json());
+            return data.message?.content || 'Sem resposta do Ollama.';
+        }
+        catch (err) {
+            throw this.formatProviderError('ollama', model, err);
+        }
+    }
+    async thinkWithGeminiCLI(systemPrompt, userMessage, model) {
+        (0, ToolsetGuard_1.assertToolsetAllowed)('delegation', 'Brain.thinkWithGeminiCLI');
+        const args = ['-o', 'json', '-m', model && model !== 'default' ? model : 'gemini-3.1-pro-preview', '-p', `${systemPrompt}\n\nMensagem: ${userMessage}`, '-y'];
+        try {
+            const { stdout } = await execFile('gemini', args, { maxBuffer: 1024 * 1024 * 10, timeout: DEFAULT_MODEL_TIMEOUT_MS });
+            const idx = stdout.indexOf('{');
+            if (idx < 0)
+                throw new Error('Resposta Gemini inválida.');
+            const parsed = JSON.parse(stdout.substring(idx));
+            return parsed.response || parsed.text || 'Sem resposta no JSON.';
+        }
+        catch (err) {
+            throw this.formatProviderError('gemini-cli', model, err);
+        }
+    }
+}
+exports.Brain = Brain;

package/dist/orchestrator/CadenceEngine.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CadenceEngine = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class CadenceEngine {
+    filePath;
+    constructor() {
+        this.filePath = path.join(process.cwd(), '.artifacts', 'cadence-events.json');
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+    }
+    schedule(kind, title, ownerRole, linkedMissionId) {
+        const event = {
+            id: `${kind}_${Date.now()}`,
+            kind,
+            title,
+            status: 'scheduled',
+            ownerRole,
+            linkedMissionId,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString()
+        };
+        const all = this.getAll();
+        all.push(event);
+        fs.writeFileSync(this.filePath, JSON.stringify(all, null, 2), 'utf-8');
+        return event;
+    }
+    updateStatus(id, status) {
+        const all = this.getAll().map((item) => item.id === id ? { ...item, status, updatedAt: new Date().toISOString() } : item);
+        fs.writeFileSync(this.filePath, JSON.stringify(all, null, 2), 'utf-8');
+    }
+    getAll() {
+        if (!fs.existsSync(this.filePath))
+            return [];
+        try {
+            return JSON.parse(fs.readFileSync(this.filePath, 'utf-8'));
+        }
+        catch {
+            return [];
+        }
+    }
+}
+exports.CadenceEngine = CadenceEngine;

package/dist/orchestrator/CapabilityRouter.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapabilityRouter = void 0;
+const IntentClassifier_1 = require("./IntentClassifier");
+class CapabilityRouter {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    route(task, input) {
+        const normalized = input.toLowerCase();
+        if (task.intent === IntentClassifier_1.TaskIntent.RESEARCH_ANALYSIS) {
+            return this.buildRoute(['analysis', 'review', 'synthesis'], 'parallel', 'Research tende a se beneficiar de múltiplos olhares e síntese.');
+        }
+        if (task.intent === IntentClassifier_1.TaskIntent.ENGINEERING_BUILD) {
+            return this.buildRoute(['orchestration', 'build', 'review', 'qa'], 'review_loop', 'Build complexo pede execução com validação crítica.');
+        }
+        if (normalized.includes('release')) {
+            return this.buildRoute(['release', 'review', 'qa'], 'review_loop', 'Release exige quality gate e validação final.');
+        }
+        return this.buildRoute(['orchestration', 'analysis'], 'single', 'Tarefa simples o suficiente para rota enxuta.');
+    }
+    buildRoute(capabilities, mode, rationale) {
+        let selected = this.registry.findMiniSquad(capabilities);
+        if (selected.length === 0) {
+            selected = this.registry.findPrioritySet().slice(0, 4);
+        }
+        return {
+            mode,
+            capabilities,
+            agents: selected,
+            rationale
+        };
+    }
+}
+exports.CapabilityRouter = CapabilityRouter;

package/dist/orchestrator/CommandLanguage.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandLanguage = void 0;
+class CommandLanguage {
+    parse(input) {
+        const trimmed = input.trim();
+        if (trimmed.startsWith('/')) {
+            const parts = trimmed.slice(1).split(/\s+/).filter(Boolean);
+            return {
+                kind: 'slash',
+                command: parts[0],
+                subcommand: parts[1],
+                args: parts.slice(2)
+            };
+        }
+        const mentionMatch = trimmed.match(/^@([a-zA-Z0-9._-]+)(?:\s+(.*))?$/);
+        if (mentionMatch) {
+            return {
+                kind: 'mention',
+                target: mentionMatch[1],
+                args: mentionMatch[2] ? [mentionMatch[2]] : []
+            };
+        }
+        return { kind: 'none' };
+    }
+}
+exports.CommandLanguage = CommandLanguage;

package/dist/orchestrator/CommandRouter.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandRouter = void 0;
+const AgentRegistry_1 = require("./AgentRegistry");
+const SquadRegistry_1 = require("./SquadRegistry");
+const SkillRegistryV2_1 = require("./SkillRegistryV2");
+const OrgStructure_1 = require("./OrgStructure");
+const ExecutionBoard_1 = require("./ExecutionBoard");
+const RoleHandoff_1 = require("./RoleHandoff");
+const CadenceEngine_1 = require("./CadenceEngine");
+class CommandRouter {
+    agents = new AgentRegistry_1.AgentRegistry();
+    squads = new SquadRegistry_1.SquadRegistry();
+    skills = new SkillRegistryV2_1.SkillRegistryV2();
+    org = new OrgStructure_1.OrgStructure();
+    board = new ExecutionBoard_1.ExecutionBoard();
+    handoffs = new RoleHandoff_1.RoleHandoff();
+    cadence = new CadenceEngine_1.CadenceEngine();
+    route(parsed) {
+        if (parsed.kind === 'slash') {
+            switch (parsed.command) {
+                case 'status':
+                    return 'Use `openlife system status` ou `openlife system doctor-world` para diagnóstico do sistema.';
+                case 'doctor':
+                    return 'Use `openlife system doctor` ou `openlife system doctor-world`.\n';
+                case 'bootstrap':
+                    return 'Use `openlife system bootstrap-world` para bootstrap world-class.';
+                case 'skills':
+                    return this.skills.all().slice(0, 20).map(s => `- ${s.id}`).join('\n');
+                case 'squads':
+                    return this.squads.all().slice(0, 20).map(s => `- ${s.id}`).join('\n');
+                case 'agents':
+                    return this.agents.all().slice(0, 20).map(a => `- ${a.id}`).join('\n');
+                case 'memory':
+                    return 'Use `openlife memory status`, `provider-list`, `provider-use` ou `test`.';
+                case 'benchmark':
+                    return 'Use `openlife benchmark run`, `compare` ou `report`.';
+                case 'swarm':
+                    return 'Use `openlife swarm run` ou `openlife swarm consensus-test`.';
+                case 'org':
+                    return this.org.all().map(r => `- ${r.id}: ${r.title}`).join('\n');
+                case 'board':
+                    return this.board.getAll().slice(0, 20).map(item => `- [${item.status}] ${item.id} (${item.ownerRole})`).join('\n') || 'Execution board vazio.';
+                case 'handoff':
+                    return this.handoffs.getAll().slice(0, 20).map(item => `- ${item.fromRole} -> ${item.toRole} [${item.status}] ${item.missionId}`).join('\n') || 'Sem handoffs.';
+                case 'cadence':
+                    return this.cadence.getAll().slice(0, 20).map(item => `- ${item.kind} [${item.status}] ${item.title}`).join('\n') || 'Sem eventos de cadence.';
+                case 'consent':
+                    return 'Use `openlife governance consent destructive <userId>` para liberar ações destrutivas por janela curta.';
+                default:
+                    return `Comando /${parsed.command} ainda não reconhecido.`;
+            }
+        }
+        if (parsed.kind === 'mention' && parsed.target) {
+            const target = parsed.target;
+            const agent = this.agents.all().find(a => a.id === target || a.name.toLowerCase() === target.toLowerCase());
+            if (agent)
+                return `Agente resolvido: ${agent.id} (${agent.role})`;
+            const squad = this.squads.all().find(s => s.id === target);
+            if (squad)
+                return `Squad resolvida: ${squad.id} (${squad.domain})`;
+            const skill = this.skills.all().find(s => s.id === target);
+            if (skill)
+                return `Skill resolvida: ${skill.id}`;
+            return `@${target} não foi resolvido em agente, squad ou skill.`;
+        }
+        return null;
+    }
+}
+exports.CommandRouter = CommandRouter;