@orkastery/cli 0.4.3 → 0.5.0

package/dist/memoria.js

@@ -35,6 +35,8 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sincronizarOnboarding = sincronizarOnboarding;
 exports.abrirMemoria = abrirMemoria;
+exports.estadoDeEmbeddings = estadoDeEmbeddings;
+exports.sondarEmbeddings = sondarEmbeddings;
 exports.tagsDoProjeto = tagsDoProjeto;
 exports.situacaoDaThread = situacaoDaThread;
 exports.situacaoDaFase = situacaoDaFase;
@@ -64,6 +66,7 @@ exports.sincronizarMemoria = sincronizarMemoria;
 exports.publicar = publicar;
 exports.publicarPropostas = publicarPropostas;
 exports.textoDoEstado = textoDoEstado;
+exports.textoDosEmbeddings = textoDosEmbeddings;
 exports.textoDoSync = textoDoSync;
 exports.parsePrioridade = parsePrioridade;
 const write_activation_1 = require("./write-activation");
@@ -97,6 +100,7 @@ const memoria_humana_1 = require("./memoria-humana");
 const master_1 = require("./master");
 const modos_1 = require("./modos");
 const orkmind_1 = require("./orkmind");
+const indice_vetorial_1 = require("./indice-vetorial");
 const ledger_1 = require("./ledger");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
@@ -167,6 +171,10 @@ function abrirMemoria(carregado, opcoes = {}) {
     const leituraRestrita = resolverLeituraRestrita(carregado.manifesto, opcoes.leituraRestrita);
     const { estado, driver } = (0, orkmind_1.resolverRegime)(carregado.manifesto, opcoes.driver ?? null);
     const ativo = estado.efetivo === 'orkmind' && driver !== null;
+    const config = (0, orkmind_1.configDoManifesto)(carregado.manifesto);
+    const embeddings = (universo) => estadoDeEmbeddings(carregado.manifesto, ativo ? driver?.disponivel().saude ?? null : null, carregado.raiz, estado.tenant, config.dsn, { universo });
+    if (estado.pedido === 'orkmind')
+        estado.embeddings = embeddings();
     const consultarRestrito = (collection, tags) => {
         if (!leituraRestrita)
             throw Error('memory.query.invalid');
@@ -178,7 +186,7 @@ function abrirMemoria(carregado, opcoes = {}) {
             throw Error('memory.query.unsupported');
         return (0, orkmind_1.concluirConsultaDelimitada)(driver.consultar(q), q);
     };
-    return {
+    const memoria = {
         configSource: context.source,
         configDivergent: context.divergent,
         get leituraRestrita() { return leituraRestrita; },
@@ -243,6 +251,114 @@ function abrirMemoria(carregado, opcoes = {}) {
             return driver.exportar(colecao).find((e) => e.id === id) ?? null;
         },
     };
+    // A cobertura precisa do universo do tenant (um export por colecao): so quando pedida.
+    if (opcoes.embeddings === 'detalhado' && ativo && !leituraRestrita) {
+        estado.embeddings = embeddings((0, indice_vetorial_1.universoDoTenant)(memoria, estado.tenant));
+    }
+    return memoria;
+}
+// ---------------------------------------------------------------------------
+// I-38 (T4, D6): estado sondado dos embeddings. Nunca derruba o regime.
+// ---------------------------------------------------------------------------
+/** Os indices locais do tenant nesta base, por modelo e dimensao. */
+function indicesDoTenant(raiz, tenant, base, universo) {
+    const dir = (0, indice_vetorial_1.dirDosIndices)(raiz, tenant);
+    if (!fs.existsSync(dir))
+        return [];
+    const indices = [];
+    for (const nome of fs.readdirSync(dir).filter(n => n.endsWith('.json')).sort()) {
+        try {
+            const bruto = JSON.parse(fs.readFileSync(path.join(dir, nome), 'utf8'));
+            if (bruto.contrato !== indice_vetorial_1.CONTRATO_INDICE || bruto.tenant !== tenant || bruto.base !== base)
+                continue;
+            const { indice } = (0, indice_vetorial_1.lerIndice)(path.join(dir, nome), { tenant, base, modelo: bruto.modelo, dim: bruto.dim });
+            const vetores = Object.keys(indice.entradas).length;
+            const coerentes = (0, indice_vetorial_1.vetoresCoerentes)(indice, universo).size;
+            indices.push({ modelo: indice.modelo, dim: indice.dim, vetores, coerentes, desatualizados: vetores - coerentes });
+        }
+        catch { /* arquivo ilegivel nao e indice: `ork memory index` o reconstroi */ }
+    }
+    return indices;
+}
+/**
+ * Estado de embeddings: configuracao, presenca da chave (nome, nunca valor), a sonda `health`
+ * da ponte e os arquivos de indice. `saude` null quer dizer que a ponte nao foi sondada.
+ */
+function estadoDeEmbeddings(manifesto, saude, raiz, tenant, dsn, opcoes = {}) {
+    const config = (0, manifest_1.configDeEmbedding)(manifesto);
+    const env = opcoes.env ?? process.env;
+    const configurado = config.provider !== 'none';
+    const variavel = config.api_key_env;
+    const bruto = variavel ? (env[variavel] ?? '').trim() : '';
+    const chavePresente = !!variavel && (0, orkmind_1.chaveDeEmbeddingAceita)(bruto, dsn);
+    const recusada = bruto !== '' && !chavePresente;
+    const dimLocal = configurado && config.fallback_model ? (0, indice_vetorial_1.dimDoModeloLocal)(config.fallback_model, env) : null;
+    const dependencias = saude?.fallback.dependencias ?? false;
+    const fallback = { modelo: config.fallback_model || null, presente: dimLocal !== null, dependencias, dim: dimLocal };
+    const base = (0, indice_vetorial_1.impressaoDaBase)(dsn);
+    const existe = (modelo, dim) => dim !== null && fs.existsSync((0, indice_vetorial_1.arquivoDoIndice)(raiz, tenant, modelo, dim));
+    const estado = {
+        configurado, provider: config.provider, modelo: configurado ? config.model : null, dim: configurado ? config.dim : null,
+        variavelDaChave: variavel, chavePresente, fallback, indices: [], entradas: null, cobertura: null,
+        ativo: 'nenhum', sondado: saude !== null, motivo: null, detalhe: '', correcao: '',
+    };
+    if (!configurado) {
+        return { ...estado, motivo: 'embeddings.nao-configurado',
+            detalhe: 'memory.embedding ausente ou provider none: busca por significado desligada; o recall por tag segue identico',
+            correcao: 'declare memory.embedding no manifesto (provider openrouter e api_key_env com o NOME da variavel da chave)' };
+    }
+    const fallbackUsavel = saude !== null && fallback.presente && dependencias;
+    if (chavePresente) {
+        estado.ativo = 'primario';
+        if (!existe(config.model, config.dim)) {
+            estado.motivo = 'embeddings.indice-ausente';
+            estado.detalhe = `chave presente em ${variavel}; o indice local de ${config.model} ainda nao existe`;
+            estado.correcao = 'rode ork memory index (use --dry-run antes para ver tokens e custo)';
+        }
+        else
+            estado.detalhe = `primario ${config.model} (${config.dim} dim) pela chave em ${variavel}`;
+    }
+    else {
+        estado.ativo = fallbackUsavel ? 'fallback' : 'nenhum';
+        estado.motivo = 'embeddings.chave-ausente';
+        const local = !fallback.modelo ? 'sem fallback local declarado: a busca por significado cai para FTS'
+            : !fallback.presente ? `fallback ${fallback.modelo} ausente do cache local: a busca cai para FTS`
+                : !saude ? 'ponte nao sondada: fallback local nao conferido'
+                    : !dependencias ? `fallback ${fallback.modelo} sem torch/transformers no interpretador da ponte: a busca cai para FTS`
+                        : `busca usa o fallback local ${fallback.modelo} (${fallback.dim} dim)` +
+                            (existe(fallback.modelo, fallback.dim) ? '' : '; indice local ausente: rode ork memory index --modelo fallback');
+        estado.detalhe = `${variavel} ${recusada ? 'tem valor recusado (parece URL, DSN ou texto com espaco; nunca impresso)' : 'nao esta no ambiente (valor nunca impresso)'}; ${local}`;
+        estado.correcao = `exporte ${variavel} com a chave dedicada ao Orkastery; o valor nunca vai ao manifesto`;
+    }
+    if (opcoes.universo) {
+        const universo = opcoes.universo.filter(e => (e.tags.project ?? []).includes(tenant));
+        estado.indices = indicesDoTenant(raiz, tenant, base, universo);
+        estado.entradas = universo.length;
+        const referencia = estado.ativo === 'fallback' ? { modelo: fallback.modelo, dim: fallback.dim } : { modelo: config.model, dim: config.dim };
+        const indice = estado.indices.find(i => i.modelo === referencia.modelo && i.dim === referencia.dim);
+        estado.cobertura = universo.length === 0 ? 0 : Math.round(((indice?.coerentes ?? 0) / universo.length) * 10_000) / 10_000;
+    }
+    return estado;
+}
+/**
+ * `ork memory status --sondar`: UMA chamada real com texto fixo curto pelo caminho ativo, com
+ * a latencia medida (primario custa cerca de US$ 0,00000005; fallback local, so CPU).
+ */
+function sondarEmbeddings(manifesto, estado, embeddar, timeoutMs) {
+    if (estado.ativo === 'nenhum')
+        return { ok: false, alvo: null, latenciaMs: null, motivo: estado.motivo };
+    const config = (0, manifest_1.configDeEmbedding)(manifesto);
+    const primario = estado.ativo === 'primario';
+    const modelo = primario ? config.model : estado.fallback.modelo;
+    const dim = primario ? config.dim : estado.fallback.dim;
+    const inicio = Date.now();
+    try {
+        embeddar({ papel: 'consulta', alvo: estado.ativo, modelo, dim, textos: ['sonda de saude do ork'] }, { timeoutMs });
+        return { ok: true, alvo: estado.ativo, latenciaMs: Date.now() - inicio, motivo: null };
+    }
+    catch (erro) {
+        return { ok: false, alvo: estado.ativo, latenciaMs: Date.now() - inicio, motivo: (0, indice_vetorial_1.codigoDeEmbedding)(erro) };
+    }
 }
 // ---------------------------------------------------------------------------
 // Tags: as 5 dimensoes, montadas em um lugar so.
@@ -968,8 +1084,38 @@ function textoDoEstado(estado) {
         linhas.push(`  colecoes gravadas: ${orkmind_1.COLECOES_DO_ORK.join(', ')}`);
         linhas.push('  governanca: source=agent; decision/human exige human_gate comprovado; mandatory=false e regra nunca critical.');
     }
+    if (estado.embeddings)
+        linhas.push('', ...textoDosEmbeddings(estado.embeddings));
     return linhas.join('\n');
 }
+/** Secao de embeddings do `ork memory status` (I-38 D6): nome da variavel, nunca o valor. */
+function textoDosEmbeddings(e) {
+    const linhas = ['Busca por significado (embeddings, nao deterministica; o recall por tag nao muda)', ''];
+    linhas.push(`  provider              ${e.configurado ? `${e.provider} ${e.modelo} (${e.dim} dim)` : 'none (desligada)'}`);
+    if (e.configurado) {
+        linhas.push(`  chave                 ${e.variavelDaChave} ${e.chavePresente ? 'presente' : 'ausente'} no ambiente (valor nunca impresso)`);
+        linhas.push(`  fallback local        ${e.fallback.modelo ? `${e.fallback.modelo}: ${e.fallback.presente ? `no cache (${e.fallback.dim} dim)` : 'ausente do cache'}, ` +
+            `dependencias ${e.fallback.dependencias ? 'ok' : e.sondado ? 'ausentes' : 'nao sondadas'}` : '(nao declarado)'}`);
+        linhas.push(`  caminho ativo         ${e.ativo}${e.sondado ? '' : ' (ponte nao sondada)'}`);
+    }
+    for (const i of e.indices) {
+        linhas.push(`  indice                ${i.modelo} / ${i.dim} dim: ${i.vetores} vetor(es), ${i.coerentes ?? '?'} coerente(s), ${i.desatualizados ?? '?'} desatualizado(s)`);
+    }
+    if (e.entradas !== null) {
+        linhas.push(`  cobertura             ${e.cobertura === null ? '-' : `${Math.round(e.cobertura * 1000) / 10}%`} de ${e.entradas} entrada(s) do tenant`);
+    }
+    if (e.sonda) {
+        linhas.push(`  sonda                 ${e.sonda.ok ? `${e.sonda.alvo} respondeu em ${e.sonda.latenciaMs} ms` : `sem resposta (${e.sonda.motivo ?? 'sem caminho ativo'})`}`);
+    }
+    if (e.motivo) {
+        linhas.push(`  motivo                ${e.motivo}`);
+        linhas.push(`    ${e.detalhe}`);
+        linhas.push(`    correcao: ${e.correcao}`);
+    }
+    else
+        linhas.push(`  ${e.detalhe}`);
+    return linhas;
+}
 /** Texto de `ork memory sync`. */
 function textoDoSync(r) {
     const linhas = [];