@openlife/cli 1.7.3

package/dist/orchestrator/VoiceManager.js

@@ -0,0 +1,203 @@
+"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.VoiceManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process = __importStar(require("child_process"));
+const util_1 = require("util");
+const openai_1 = __importDefault(require("openai"));
+const VoiceRouter_1 = require("./VoiceRouter");
+const ToolsetGuard_1 = require("./toolset/ToolsetGuard");
+const execFile = (0, util_1.promisify)(child_process.execFile);
+class VoiceManager {
+    elevenLabsApiKey;
+    voiceRouter;
+    openai = null;
+    constructor() {
+        this.elevenLabsApiKey = process.env.ELEVENLABS_API_KEY;
+        this.voiceRouter = new VoiceRouter_1.VoiceRouter();
+        const openAIKey = process.env.OPENAI_API_KEY;
+        if (openAIKey && openAIKey.trim() !== '') {
+            this.openai = new openai_1.default({ apiKey: openAIKey });
+        }
+    }
+    async processAudioInput(fileLink) {
+        const sttOrder = this.voiceRouter.getSttOrder();
+        let lastError = null;
+        for (const provider of sttOrder) {
+            try {
+                switch (provider) {
+                    case 'gemini':
+                        return await this.transcribeWithGemini(fileLink);
+                    case 'openai':
+                        return await this.transcribeWithOpenAI(fileLink);
+                    default:
+                        throw new Error(`[VOICE] Provider de STT desconhecido: ${provider}`);
+                }
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                const msg = lastError.message;
+                console.log(`[VOICE] Falha no provider STT ${provider}:`, msg);
+                this.logMediaRoute('stt', provider, 'failed', msg);
+            }
+        }
+        throw lastError || new Error('[VOICE] Nenhum provider de STT disponível.');
+    }
+    async generateSpeech(text, voiceId) {
+        (0, ToolsetGuard_1.assertToolsetAllowed)('tts', 'VoiceManager.generateSpeech');
+        const ttsOrder = this.voiceRouter.getTtsOrder();
+        const selectedVoice = voiceId || this.voiceRouter.getDefaultVoice() || 'EXAVITQu4vr4xnSDxMaL';
+        let lastError = null;
+        for (const provider of ttsOrder) {
+            try {
+                switch (provider) {
+                    case 'gemini':
+                        return await this.generateSpeechWithGemini(text);
+                    case 'elevenlabs':
+                        return await this.generateSpeechWithElevenLabs(text, selectedVoice);
+                    case 'piper':
+                        throw new Error('[VOICE] Piper ainda não implementado no runtime atual.');
+                    case 'openai':
+                        return await this.generateSpeechWithOpenAI(text, selectedVoice);
+                    default:
+                        throw new Error(`[VOICE] Provider de TTS desconhecido: ${provider}`);
+                }
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                const msg = lastError.message;
+                console.log(`[VOICE] Falha no provider ${provider}:`, msg);
+                this.logMediaRoute('tts', provider, 'failed', msg);
+            }
+        }
+        throw lastError || new Error('[VOICE] Nenhum provider de TTS disponível.');
+    }
+    async transcribeWithGemini(fileLink) {
+        const candidates = ['gemini-3.1-flash-lite-preview', 'gemini-2.5-flash', 'gemini-3.1-pro-preview'];
+        let lastError = null;
+        for (const model of candidates) {
+            try {
+                const args = ['-o', 'json', '-m', model, '-p', `Transcreva fielmente este áudio em português do Brasil: @${fileLink}`, '-y'];
+                const { stdout } = await execFile('gemini', args, { maxBuffer: 1024 * 1024 * 10, timeout: 120000 });
+                const jsonStart = stdout.indexOf('{');
+                if (jsonStart === -1)
+                    throw new Error('Resposta Gemini inválida para STT.');
+                const parsed = JSON.parse(stdout.slice(jsonStart));
+                const text = String(parsed.response || parsed.text || '').trim();
+                if (!text)
+                    throw new Error('Transcrição vazia no Gemini STT.');
+                this.logMediaRoute('stt', `gemini:${model}`, 'success');
+                return text;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                const reason = lastError.message.toLowerCase();
+                this.logMediaRoute('stt', `gemini:${model}`, 'failed', lastError.message);
+                if (!/429|resource_exhausted|capacity|rate limit|quota/.test(reason))
+                    break;
+            }
+        }
+        throw new Error(`Falha STT Gemini fallback-chain: ${lastError?.message || 'unknown error'}`);
+    }
+    async transcribeWithOpenAI(_fileLink) {
+        throw new Error('OpenAI STT fallback ainda não implementado neste runtime.');
+    }
+    async generateSpeechWithGemini(_text) {
+        throw new Error('Gemini TTS indisponível neste runtime; acionando fallback controlado.');
+    }
+    async generateSpeechWithOpenAI(text, voiceId = 'nova') {
+        if (!this.openai) {
+            throw new Error('[VOICE] OPENAI_API_KEY não configurada.');
+        }
+        const response = await this.openai.audio.speech.create({
+            model: 'gpt-4o-mini-tts',
+            voice: voiceId,
+            input: text
+        });
+        const buffer = Buffer.from(await response.arrayBuffer());
+        const outputDir = path.join(process.cwd(), '.temp_audio');
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        const fileName = `speech_openai_${Date.now()}.mp3`;
+        const filePath = path.join(outputDir, fileName);
+        fs.writeFileSync(filePath, buffer);
+        this.logMediaRoute('tts', 'openai', 'success');
+        return filePath;
+    }
+    async generateSpeechWithElevenLabs(text, voiceId) {
+        if (!this.elevenLabsApiKey) {
+            throw new Error('[VOICE] ELEVENLABS_API_KEY não configurada.');
+        }
+        const url = `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Accept': 'audio/mpeg',
+                'Content-Type': 'application/json',
+                'xi-api-key': this.elevenLabsApiKey
+            },
+            body: JSON.stringify({
+                text,
+                model_id: 'eleven_multilingual_v2',
+                voice_settings: { stability: 0.5, similarity_boost: 0.75 }
+            })
+        });
+        if (!response.ok) {
+            throw new Error(`[VOICE] Erro ElevenLabs: ${response.statusText}`);
+        }
+        const buffer = await response.arrayBuffer();
+        const outputDir = path.join(process.cwd(), '.temp_audio');
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        const fileName = `speech_${Date.now()}.mp3`;
+        const filePath = path.join(outputDir, fileName);
+        fs.writeFileSync(filePath, Buffer.from(buffer));
+        this.logMediaRoute('tts', 'elevenlabs', 'success');
+        return filePath;
+    }
+    logMediaRoute(kind, provider, status, detail) {
+        const file = path.join(process.cwd(), '.openlife', 'media-routing.log.jsonl');
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.appendFileSync(file, JSON.stringify({ ts: new Date().toISOString(), kind, provider, status, detail: detail || '' }) + '\n', 'utf-8');
+    }
+}
+exports.VoiceManager = VoiceManager;

package/dist/orchestrator/VoiceRouter.js

@@ -0,0 +1,89 @@
+"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.VoiceRouter = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class VoiceRouter {
+    configPath;
+    constructor() {
+        this.configPath = path.join(process.cwd(), 'voice.config.json');
+    }
+    isGeminiPreferredForMedia() {
+        return (process.env.OPENLIFE_PREFER_GEMINI_FOR_MEDIA || 'true').toLowerCase() === 'true';
+    }
+    getConfig() {
+        const fallbackConfig = {
+            defaultProfile: 'default',
+            profiles: {
+                default: {
+                    stt: { order: ['gemini', 'openai'], mode: 'fallback' },
+                    tts: { order: ['gemini', 'openai', 'elevenlabs'], mode: 'fallback', defaultVoice: 'nova' }
+                }
+            }
+        };
+        if (!fs.existsSync(this.configPath)) {
+            return this.applyGeminiPreference(fallbackConfig);
+        }
+        const raw = fs.readFileSync(this.configPath, 'utf-8');
+        return this.applyGeminiPreference(JSON.parse(raw));
+    }
+    applyGeminiPreference(config) {
+        if (!this.isGeminiPreferredForMedia())
+            return config;
+        const profileName = config.defaultProfile;
+        const profile = config.profiles[profileName];
+        if (!profile)
+            return config;
+        profile.stt.order = ['gemini', ...profile.stt.order.filter(p => p !== 'gemini')];
+        profile.tts.order = ['gemini', ...profile.tts.order.filter(p => p !== 'gemini')];
+        return config;
+    }
+    getProfile(profileName) {
+        const config = this.getConfig();
+        const selected = profileName || config.defaultProfile;
+        return config.profiles[selected] || config.profiles[config.defaultProfile];
+    }
+    getTtsOrder(profileName) {
+        return this.getProfile(profileName).tts.order;
+    }
+    getSttOrder(profileName) {
+        return this.getProfile(profileName).stt.order;
+    }
+    getDefaultVoice(profileName) {
+        return this.getProfile(profileName).tts.defaultVoice;
+    }
+}
+exports.VoiceRouter = VoiceRouter;

package/dist/orchestrator/capability/CapabilityGenesisEngine.js

@@ -0,0 +1,278 @@
+"use strict";
+/**
+ * CapabilityGenesisEngine — orchestrates existing creators to produce a
+ * draft Capability Pack from a free-form brief.
+ *
+ * Story 1.5 — OpenLife v1.3 Agent OS Integration.
+ *
+ * Reuse-first contract (Rafa-locked decision, 2026-05-12):
+ *   1. Call AssetReuseRouter.find(brief) — if existing asset covers the
+ *      brief, the pack references it (`source: 'referenced'`) instead of
+ *      creating a duplicate.
+ *   2. Only when no reusable asset is found does Genesis call the
+ *      relevant creator (SkillCreator, SquadCreator) and embed the new
+ *      asset under the pack directory (`source: 'embedded'`).
+ *
+ * Never auto-promotes. Always produces a `status: 'draft'` pack. Caller
+ * (CLI handler or operator) is responsible for promote → tested → active
+ * via CapabilityPackStateStore.
+ *
+ * Brain integration: when called with a Brain instance, Genesis asks for
+ * a structured proposal (which skills/squads/workflows the pack should
+ * contain). When Brain is omitted (test/offline mode), Genesis falls back
+ * to a heuristic that produces a single-skill pack from the brief.
+ */
+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.CapabilityGenesisEngine = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const AtomicWriter_1 = require("../util/AtomicWriter");
+const yaml = __importStar(require("js-yaml"));
+const CapabilityPackState_1 = require("./CapabilityPackState");
+const AssetReuseRouter_1 = require("../AssetReuseRouter");
+const SkillCreator_1 = require("../SkillCreator");
+const SquadCreator_1 = require("../SquadCreator");
+class CapabilityGenesisEngine {
+    catalogRoot;
+    skillCreator;
+    squadCreator;
+    assetReuseRouter;
+    stateStore;
+    constructor(opts = {}) {
+        this.catalogRoot = opts.catalogRoot
+            || path.join(process.cwd(), '.catalog', 'capabilities');
+        this.skillCreator = opts.skillCreator || new SkillCreator_1.SkillCreator();
+        this.squadCreator = opts.squadCreator || new SquadCreator_1.SquadCreator();
+        this.assetReuseRouter = opts.assetReuseRouter || new AssetReuseRouter_1.AssetReuseRouter();
+        this.stateStore = opts.stateStore || new CapabilityPackState_1.CapabilityPackStateStore();
+    }
+    generate(brief) {
+        const packId = brief.packId || slugify(brief.description).slice(0, 60);
+        if (!/^[a-z0-9][a-z0-9._-]+$/i.test(packId)) {
+            return { ok: false, error: 'invalid_pack_id', detail: packId };
+        }
+        const packDir = path.join(this.catalogRoot, packId);
+        if (fs.existsSync(packDir)) {
+            return { ok: false, error: 'pack_already_exists', detail: packDir };
+        }
+        // Reuse-first: find existing promoted assets that match the brief
+        const reusedRaw = this.assetReuseRouter.find(brief.description);
+        const reusedAssets = reusedRaw.map((a) => a.id);
+        // Build the pack manifest. The hints drive what Genesis tries to
+        // create when no reusable asset is found. In 'quick' mode we only
+        // wire one skill; 'professional' adds a squad; 'elite' adds a full
+        // workflow stub too.
+        const mode = brief.mode || 'professional';
+        const skillsToInclude = brief.hints?.skills || [];
+        const squadsToInclude = brief.hints?.squads || [];
+        const workflowsToInclude = brief.hints?.workflows || [];
+        const createdAssets = [];
+        const skillRefs = [];
+        const squadRefs = [];
+        const workflowRefs = [];
+        // Create pack directory skeleton first so embedded creates land here.
+        fs.mkdirSync(packDir, { recursive: true });
+        for (const sub of ['skills', 'squads', 'agents', 'workflows', 'checklists', 'templates']) {
+            fs.mkdirSync(path.join(packDir, sub), { recursive: true });
+        }
+        // Skills
+        for (const skillId of skillsToInclude) {
+            const reuseHit = reusedAssets.find((a) => a.toLowerCase().includes(skillId.toLowerCase()));
+            if (reuseHit) {
+                skillRefs.push({ id: skillId, source: 'referenced', label: `Reused: ${reuseHit}` });
+                continue;
+            }
+            // Embed: create a stub skill inside the pack
+            const stubPath = path.join(packDir, 'skills', `${skillId}.md`);
+            (0, AtomicWriter_1.writeStringAtomic)(stubPath, this.skillStub(skillId, brief.description));
+            skillRefs.push({ id: skillId, source: 'embedded' });
+            createdAssets.push(`skills/${skillId}.md`);
+        }
+        // Squads — only in professional/elite mode
+        if (mode === 'professional' || mode === 'elite') {
+            for (const squadId of squadsToInclude) {
+                const stubDir = path.join(packDir, 'squads', squadId);
+                fs.mkdirSync(stubDir, { recursive: true });
+                (0, AtomicWriter_1.writeStringAtomic)(path.join(stubDir, 'SQUAD.md'), this.squadStub(squadId, brief.description));
+                squadRefs.push({ id: squadId, source: 'embedded' });
+                createdAssets.push(`squads/${squadId}/SQUAD.md`);
+            }
+        }
+        // Workflows — only in elite mode
+        if (mode === 'elite') {
+            for (const wfId of workflowsToInclude) {
+                const stubPath = path.join(packDir, 'workflows', `${wfId}.yaml`);
+                (0, AtomicWriter_1.writeStringAtomic)(stubPath, this.workflowStub(wfId, brief.description));
+                workflowRefs.push({ id: wfId, source: 'embedded' });
+                createdAssets.push(`workflows/${wfId}.yaml`);
+            }
+        }
+        // Build the manifest
+        const pack = {
+            id: packId,
+            name: brief.packName || titleCase(packId),
+            description: brief.description,
+            version: '0.1.0',
+            status: 'draft',
+            objective: brief.description,
+            skills: skillRefs.length > 0 ? skillRefs : undefined,
+            squads: squadRefs.length > 0 ? squadRefs : undefined,
+            workflows: workflowRefs.length > 0 ? workflowRefs : undefined,
+            metadata: {
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                author: brief.actor,
+                tags: [mode],
+            },
+        };
+        const manifestYaml = yaml.dump({ capability: pack }, { lineWidth: 100 });
+        const manifestPath = path.join(packDir, 'capability.yaml');
+        (0, AtomicWriter_1.writeStringAtomic)(manifestPath, manifestYaml);
+        // INDEX.md — quick browsable summary
+        const indexMd = this.renderIndexMd(pack, reusedAssets, createdAssets);
+        (0, AtomicWriter_1.writeStringAtomic)(path.join(packDir, 'INDEX.md'), indexMd);
+        // Initialize lifecycle status
+        this.stateStore.init(packId, brief.actor);
+        return {
+            ok: true,
+            packId,
+            packDir,
+            manifestPath,
+            pack,
+            reusedAssets,
+            createdAssets,
+        };
+    }
+    skillStub(skillId, briefText) {
+        return `---
+id: ${skillId}
+name: ${skillId}
+status: draft
+source: capability-genesis
+version: 0.1.0
+---
+
+# ${skillId}
+
+> Auto-generated stub from CapabilityGenesisEngine.
+> Brief: ${briefText}
+
+## When to use
+
+- TBD — operator must refine
+
+## Procedure
+
+1. TBD — operator must refine
+
+## Validation
+
+- TBD — operator must refine
+`;
+    }
+    squadStub(squadId, briefText) {
+        return `---
+id: ${squadId}
+name: ${squadId}
+status: draft
+source: capability-genesis
+version: 0.1.0
+---
+
+# ${squadId}
+
+> Auto-generated stub from CapabilityGenesisEngine.
+> Brief: ${briefText}
+
+## Agents
+
+| Agent | Role |
+|-------|------|
+| TBD   | TBD  |
+`;
+    }
+    workflowStub(wfId, briefText) {
+        return `workflow:
+  id: ${wfId}
+  name: ${wfId}
+  description: "${briefText.replace(/"/g, '\\"')}"
+  type: custom
+  version: "0.1.0"
+  sequence:
+    - phase: 0
+      name: planning
+      description: TBD — operator must refine
+    - id: step-1
+      agent: planner
+      action: plan
+      notes: |
+        Auto-generated stub. Operator must refine.
+`;
+    }
+    renderIndexMd(pack, reused, created) {
+        const lines = [
+            `# ${pack.name}`,
+            '',
+            `> ${pack.description}`,
+            '',
+            `**Status:** ${pack.status} • **Version:** ${pack.version}`,
+            '',
+            `## Objective`,
+            pack.objective,
+            '',
+        ];
+        if (pack.skills?.length) {
+            lines.push('## Skills', ...pack.skills.map((s) => `- \`${s.id}\` (${s.source})`), '');
+        }
+        if (pack.squads?.length) {
+            lines.push('## Squads', ...pack.squads.map((s) => `- \`${s.id}\` (${s.source})`), '');
+        }
+        if (pack.workflows?.length) {
+            lines.push('## Workflows', ...pack.workflows.map((s) => `- \`${s.id}\` (${s.source})`), '');
+        }
+        lines.push('## Genesis report', '');
+        lines.push(`Reused assets: ${reused.length ? reused.join(', ') : '(none)'}`);
+        lines.push(`Created assets: ${created.length ? created.join(', ') : '(none)'}`);
+        return lines.join('\n') + '\n';
+    }
+}
+exports.CapabilityGenesisEngine = CapabilityGenesisEngine;
+function slugify(s) {
+    return s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+}
+function titleCase(s) {
+    return s.split(/[-_]/).map((w) => w[0]?.toUpperCase() + w.slice(1)).join(' ');
+}