@orkastery/cli 0.4.2 → 0.5.0

package/dist/indice-vetorial.js

@@ -0,0 +1,317 @@
+"use strict";
+/**
+ * I-38 (T3, D2, D10, D11): indice vetorial LOCAL e DERIVADO da memoria do tenant.
+ *
+ * A DSN declarada le e nao escreve (medido no PLAN), e a coluna `embedding` da base
+ * compartilhada guarda vetores de outros produtos. Por isso o vetor do `ork` mora aqui, no
+ * estado canonico do projeto, um arquivo por tenant, modelo e dimensao:
+ *
+ *   <raiz canonica>/.orkastery/memoria/vetores/<tenant>/<modelo>-<dim>.json   (0600, fora do git)
+ *
+ * O OrkMind continua a fonte da verdade; o indice e cache reconstruivel por `ork memory index`.
+ * A chave de cada vetor e (id, sha256 do content, modelo, dim): conteudo que mudou reembeda so
+ * aquela entrada, e arquivo de outro modelo, dimensao, tenant ou base nunca e misturado.
+ */
+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.PRECO_USD_POR_TOKEN = exports.TIMEOUT_DO_LOTE_MS = exports.CARACTERES_POR_TOKEN = exports.TAMANHO_DO_LOTE = exports.CONTRATO_INDICE = void 0;
+exports.dirDosIndices = dirDosIndices;
+exports.arquivoDoIndice = arquivoDoIndice;
+exports.sha256DoConteudo = sha256DoConteudo;
+exports.impressaoDaBase = impressaoDaBase;
+exports.codificarVetor = codificarVetor;
+exports.decodificarVetor = decodificarVetor;
+exports.lerIndice = lerIndice;
+exports.serializarIndice = serializarIndice;
+exports.gravarIndice = gravarIndice;
+exports.universoDoTenant = universoDoTenant;
+exports.conteudoRecusado = conteudoRecusado;
+exports.tokensEstimados = tokensEstimados;
+exports.dimDoModeloLocal = dimDoModeloLocal;
+exports.codigoDeEmbedding = codigoDeEmbedding;
+exports.espacoDoAlvo = espacoDoAlvo;
+exports.indexar = indexar;
+exports.vetoresCoerentes = vetoresCoerentes;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const estado_thread_1 = require("./estado-thread");
+const orkmind_1 = require("./orkmind");
+const policies_1 = require("./policies");
+exports.CONTRATO_INDICE = 'ork.indice-vetorial/v1';
+/** D11: lote por chamada da ponte na indexacao. */
+exports.TAMANHO_DO_LOTE = 16;
+/** D11: estimativa conservadora para portugues; o provider da biblioteca descarta `usage`. */
+exports.CARACTERES_POR_TOKEN = 3;
+/** Indexar e trabalho de lote (madrugada), com prazo proprio; a consulta usa o prazo da ponte. */
+exports.TIMEOUT_DO_LOTE_MS = 120_000;
+/**
+ * D11: preco publico por token de entrada, conferido em 29/09/2026 com
+ * `curl -s https://openrouter.ai/api/v1/embeddings/models`. Estimativa: a fatura e o painel.
+ */
+exports.PRECO_USD_POR_TOKEN = Object.freeze({
+    'qwen/qwen3-embedding-8b': 0.00000001,
+});
+/** URL com credencial: o texto nunca vai ao provider. */
+const URL_COM_CREDENCIAL = /\b[a-z][a-z0-9+.-]*:\/\/[^\s/:@]+:[^\s/@]+@/;
+const seguro = (nome) => nome.replace(/\//g, '__').replace(/[^A-Za-z0-9_-]/g, '_');
+function dirDosIndices(raiz, tenant) {
+    return path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'memoria', 'vetores', seguro(tenant));
+}
+function arquivoDoIndice(raiz, tenant, modelo, dim) {
+    return path.join(dirDosIndices(raiz, tenant), `${seguro(modelo)}-${dim}.json`);
+}
+function sha256DoConteudo(conteudo) {
+    return (0, node_crypto_1.createHash)('sha256').update(conteudo, 'utf8').digest('hex');
+}
+/** Impressao da base: host, porta e banco, sem usuario nem senha. */
+function impressaoDaBase(dsn) {
+    let alvo = '';
+    try {
+        const u = new URL(dsn);
+        alvo = `${u.hostname}:${u.port || '5432'}${u.pathname}`;
+    }
+    catch {
+        const campo = (k) => new RegExp(`(?:^|\\s)${k}=([^\\s]+)`).exec(dsn)?.[1] ?? '';
+        alvo = `${campo('host')}:${campo('port') || '5432'}/${campo('dbname')}`;
+    }
+    return (0, node_crypto_1.createHash)('sha256').update(alvo).digest('hex');
+}
+function codificarVetor(v) {
+    const buf = Buffer.alloc(v.length * 4);
+    v.forEach((x, i) => buf.writeFloatLE(x, i * 4));
+    return buf.toString('base64');
+}
+function decodificarVetor(b64, dim) {
+    const buf = Buffer.from(b64, 'base64');
+    if (buf.length !== dim * 4)
+        return null;
+    return Array.from({ length: dim }, (_, i) => buf.readFloatLE(i * 4));
+}
+/**
+ * Le o indice de (tenant, base, modelo, dim). Arquivo ausente, ilegivel ou de outro espaco
+ * vetorial volta vazio: reconstruir custa centesimos de centavo, misturar corrompe a busca.
+ */
+function lerIndice(arquivo, esperado) {
+    const vazio = { contrato: exports.CONTRATO_INDICE, ...esperado, entradas: {} };
+    if (!fs.existsSync(arquivo))
+        return { indice: vazio, existia: false, outroEspaco: false };
+    try {
+        const o = JSON.parse(fs.readFileSync(arquivo, 'utf8'));
+        if (o.contrato !== exports.CONTRATO_INDICE || o.tenant !== esperado.tenant || o.base !== esperado.base ||
+            o.modelo !== esperado.modelo || o.dim !== esperado.dim || !o.entradas || typeof o.entradas !== 'object') {
+            return { indice: vazio, existia: true, outroEspaco: true };
+        }
+        const entradas = {};
+        for (const [id, e] of Object.entries(o.entradas)) {
+            if (e && typeof e.sha256 === 'string' && typeof e.colecao === 'string' && typeof e.vetor === 'string' &&
+                decodificarVetor(e.vetor, esperado.dim))
+                entradas[id] = e;
+        }
+        return { indice: { ...vazio, entradas }, existia: true, outroEspaco: false };
+    }
+    catch {
+        return { indice: vazio, existia: true, outroEspaco: true };
+    }
+}
+/** Serializacao estavel: mesma memoria, mesmos bytes (idempotencia provada por comparacao). */
+function serializarIndice(indice) {
+    const entradas = Object.fromEntries(Object.keys(indice.entradas).sort().map(id => [id, {
+            colecao: indice.entradas[id].colecao, sha256: indice.entradas[id].sha256, vetor: indice.entradas[id].vetor
+        }]));
+    return JSON.stringify({ contrato: indice.contrato, tenant: indice.tenant, base: indice.base,
+        modelo: indice.modelo, dim: indice.dim, entradas }, null, 1) + '\n';
+}
+/** Escrita atomica, pasta 0700 e arquivo 0600; so grava quando os bytes mudam. */
+function gravarIndice(arquivo, indice) {
+    const bytes = serializarIndice(indice);
+    if (fs.existsSync(arquivo) && fs.readFileSync(arquivo, 'utf8') === bytes)
+        return false;
+    const dir = path.dirname(arquivo);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fs.chmodSync(dir, 0o700);
+    const tmp = `${arquivo}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, bytes, { mode: 0o600 });
+    fs.renameSync(tmp, arquivo);
+    fs.chmodSync(arquivo, 0o600);
+    return true;
+}
+/**
+ * Universo do tenant: o export governado das colecoes do ork (filtro de injecao e visibilidade
+ * da biblioteca), com checagem EXPLICITA do tenant antes de qualquer texto ir ao embed.
+ */
+function universoDoTenant(fonte, tenant, colecoes = orkmind_1.COLECOES_DO_ORK) {
+    return colecoes.flatMap(c => fonte.buscar({ collection: c, tags: { project: [tenant] } })
+        .filter(e => e.collection === c && (e.tags.project ?? []).includes(tenant)))
+        .sort((a, b) => a.collection.localeCompare(b.collection) || a.id.localeCompare(b.id));
+}
+/** Conteudo que nunca vai ao provider: padrao de segredo da policy ou URL com credencial. */
+function conteudoRecusado(conteudo) {
+    return (0, policies_1.procurarSegredos)(conteudo).length > 0 || URL_COM_CREDENCIAL.test(conteudo);
+}
+function tokensEstimados(conteudo) {
+    return Math.ceil(conteudo.length / exports.CARACTERES_POR_TOKEN);
+}
+/**
+ * Dimensao nativa de um modelo local, lida do cache do Hugging Face sem rede e sem Python.
+ * null quando o modelo nao esta no cache (a busca cai para FTS com `embeddings.local-ausente`).
+ */
+function dimDoModeloLocal(modelo, env = process.env) {
+    if (!modelo || !orkmind_1.MODELO_DE_EMBEDDING.test(modelo))
+        return null;
+    const hub = env.HF_HUB_CACHE || path.join(env.HF_HOME || path.join(env.HOME || os.homedir(), '.cache', 'huggingface'), 'hub');
+    const repo = path.join(hub, `models--${modelo.replace('/', '--')}`);
+    try {
+        const ref = fs.readFileSync(path.join(repo, 'refs', 'main'), 'utf8').trim();
+        if (!/^[0-9a-f]{40}$/.test(ref))
+            return null;
+        const config = JSON.parse(fs.readFileSync(path.join(repo, 'snapshots', ref, 'config.json'), 'utf8'));
+        const dim = Number(config.hidden_size ?? config.d_model ?? config.dim);
+        return Number.isInteger(dim) && dim >= 32 && dim <= 4096 ? dim : null;
+    }
+    catch {
+        return null;
+    }
+}
+function codigoDeEmbedding(erro) {
+    const m = erro instanceof Error ? erro.message : '';
+    const tipado = /^embeddings\.[a-z-]+/.exec(m)?.[0];
+    if (m === 'memory.transport.timeout')
+        return 'embeddings.timeout';
+    if (m.startsWith('memory.transport.secret'))
+        return 'embeddings.conteudo-recusado';
+    return tipado ?? 'embeddings.provider-indisponivel';
+}
+/** O par (modelo, dim) de cada alvo, ou o motivo tipado de nao haver. */
+function espacoDoAlvo(config, alvo, env = process.env) {
+    if (config.provider === 'none')
+        return { motivo: 'embeddings.nao-configurado', detalhe: 'memory.embedding.provider none' };
+    if (alvo === 'primario')
+        return { modelo: config.model, dim: config.dim };
+    if (!config.fallback_model)
+        return { motivo: 'embeddings.nao-configurado', detalhe: 'memory.embedding.fallback_model vazio' };
+    const dim = dimDoModeloLocal(config.fallback_model, env);
+    if (dim === null)
+        return { motivo: 'embeddings.local-ausente', detalhe: `${config.fallback_model} ausente do cache local do Hugging Face` };
+    return { modelo: config.fallback_model, dim };
+}
+/**
+ * `ork memory index`: idempotente, com o teto de tokens conferido ANTES da rede.
+ *
+ * Pendentes sao as entradas do universo sem vetor coerente; removidos, as do indice que sairam
+ * do tenant; fora do limite e recusados nunca vao ao provider. Falha no meio preserva os lotes
+ * que ja voltaram, porque cada vetor gravado e coerente por si.
+ */
+function indexar(o) {
+    const espaco = espacoDoAlvo(o.config, o.alvo, o.env);
+    const universo = o.universo.filter(e => (e.tags.project ?? []).includes(o.tenant));
+    const foraDoLimite = universo.filter(e => e.content.length > orkmind_1.EMBED_MAX_CARACTERES);
+    const recusados = universo.filter(e => e.content.length <= orkmind_1.EMBED_MAX_CARACTERES && conteudoRecusado(e.content));
+    const indexaveis = universo.filter(e => e.content.length <= orkmind_1.EMBED_MAX_CARACTERES && !conteudoRecusado(e.content) && e.content.trim());
+    const base = { alvo: o.alvo, modelo: null, dim: null, arquivo: null, dryRun: o.dryRun,
+        universo: universo.length, coerentes: 0, embedados: 0, reescritos: 0, removidos: 0, recusados: recusados.length,
+        foraDoLimite: foraDoLimite.length, truncados: 0, tokensEstimados: 0, custoEstimadoUsd: 0, chamadasAoProvider: 0, motivo: null, detalhe: '' };
+    if ('motivo' in espaco) {
+        const tokens = indexaveis.reduce((t, e) => t + tokensEstimados(e.content), 0);
+        return { ...base, tokensEstimados: tokens, motivo: espaco.motivo, detalhe: espaco.detalhe };
+    }
+    const arquivo = arquivoDoIndice(o.raiz, o.tenant, espaco.modelo, espaco.dim);
+    const { indice } = lerIndice(arquivo, { tenant: o.tenant, base: impressaoDaBase(o.dsn), modelo: espaco.modelo, dim: espaco.dim });
+    const ids = new Set(indexaveis.map(e => e.id));
+    const coerente = (e) => indice.entradas[e.id]?.sha256 === sha256DoConteudo(e.content);
+    const pendentes = indexaveis.filter(e => !coerente(e));
+    const removidos = Object.keys(indice.entradas).filter(id => !ids.has(id));
+    const tokens = pendentes.reduce((t, e) => t + tokensEstimados(e.content), 0);
+    const preco = o.alvo === 'fallback' ? 0 : exports.PRECO_USD_POR_TOKEN[espaco.modelo];
+    const r = { ...base, modelo: espaco.modelo, dim: espaco.dim,
+        arquivo: path.relative((0, estado_thread_1.raizDoEstado)(o.raiz), arquivo).split(path.sep).join('/'),
+        coerentes: indexaveis.length - pendentes.length, removidos: removidos.length, tokensEstimados: tokens,
+        custoEstimadoUsd: preco === undefined ? null : tokens * preco,
+        detalhe: preco === undefined ? `preco de ${espaco.modelo} fora da tabela datada: custo nao estimado` : '' };
+    if (o.dryRun)
+        return r;
+    if (o.alvo === 'primario' && !o.chavePresente) {
+        return { ...r, motivo: 'embeddings.chave-ausente', detalhe: o.chaveRecusada
+                ? 'a variavel declarada em memory.embedding.api_key_env tem valor recusado (parece URL, DSN ou texto com espaco; nunca impresso)'
+                : 'a variavel declarada em memory.embedding.api_key_env nao esta no ambiente' };
+    }
+    // D11: o teto de dinheiro vale antes de qualquer chamada; o fallback local nao cobra.
+    if (o.alvo === 'primario' && tokens > o.config.max_tokens_por_execucao) {
+        return { ...r, motivo: 'embeddings.orcamento-excedido',
+            detalhe: `${tokens} tokens estimados acima do teto de ${o.config.max_tokens_por_execucao} por execucao` };
+    }
+    if (!o.embeddar)
+        return { ...r, motivo: 'embeddings.provider-indisponivel', detalhe: 'transporte de embedding ausente' };
+    for (const id of removidos)
+        delete indice.entradas[id];
+    let motivo = null;
+    for (let i = 0; i < pendentes.length && !motivo; i += exports.TAMANHO_DO_LOTE) {
+        const lote = pendentes.slice(i, i + exports.TAMANHO_DO_LOTE);
+        r.chamadasAoProvider += 1;
+        try {
+            const resposta = o.embeddar({ papel: 'documento', alvo: o.alvo, modelo: espaco.modelo, dim: espaco.dim,
+                textos: lote.map(e => e.content) }, { timeoutMs: exports.TIMEOUT_DO_LOTE_MS });
+            lote.forEach((e, j) => {
+                if (indice.entradas[e.id])
+                    r.reescritos += 1;
+                indice.entradas[e.id] = { colecao: e.collection, sha256: sha256DoConteudo(e.content), vetor: codificarVetor(resposta.vetores[j]) };
+                r.embedados += 1;
+            });
+            r.truncados += resposta.truncados?.length ?? 0;
+        }
+        catch (erro) {
+            motivo = codigoDeEmbedding(erro);
+        }
+    }
+    gravarIndice(arquivo, indice);
+    r.coerentes = indexaveis.filter(coerente).length;
+    if (motivo)
+        return { ...r, motivo, detalhe: `indexacao interrompida depois de ${r.embedados} vetor(es); os lotes concluidos ficaram gravados` };
+    return r;
+}
+/** Vetores coerentes de um indice para o universo informado: a base da busca e da cobertura. */
+function vetoresCoerentes(indice, universo) {
+    const saida = new Map();
+    for (const e of universo) {
+        const item = indice.entradas[e.id];
+        if (!item || item.sha256 !== sha256DoConteudo(e.content))
+            continue;
+        const v = decodificarVetor(item.vetor, indice.dim);
+        if (v)
+            saida.set(e.id, v);
+    }
+    return saida;
+}

package/dist/init.js

@@ -156,6 +156,10 @@ owner:
   # fuso do dono (nome IANA): todo horario mostrado a pessoas usa este fuso.
   # Ausente: fuso do sistema. Exemplo:
   # timezone: "${horario_1.FUSO_DE_BRASILIA}"
+  # Preferências: ork onboarding set maestro --conteudo '{"owner":{"experience":true}}'
+  # language: pt-BR  # ausente: locale do sistema
+  # depth: curta    # curta | detalhada
+  # experience: true  # false desativa o pacote na próxima instalação do adaptador
 
 board:
   adapter: hermes-kanban
@@ -227,6 +231,15 @@ memory:
   database_url_env: ""
   cli: orkmind
   timeout_ms: 15000
+  # busca por significado (ork memory search --texto): sem o bloco, provider none (desligada).
+  # api_key_env recebe o NOME da variavel com a chave dedicada, nunca o valor.
+  # embedding:
+  #   provider: "none"            # none | openrouter
+  #   model: "qwen/qwen3-embedding-8b"
+  #   dim: 1024
+  #   api_key_env: "ORKASTERY_EMBEDDING_API_KEY"
+  #   fallback_model: ""          # modelo local offline, ex.: intfloat/multilingual-e5-small
+  #   max_tokens_por_execucao: 1000000
 
 audit:
   # governanca de custo dos auditores periodicos (bloco B5)

package/dist/integracoes-locais.js

@@ -10,7 +10,7 @@ exports.TESTES_DE_INTEGRACAO_LOCAL = void 0;
  * daqui, e o script le o mesmo modulo ja compilado em `dist/` (o `test:ci` compila antes).
  */
 exports.TESTES_DE_INTEGRACAO_LOCAL = new Set([
-    'codex-controller-sensor.test.js', 'consulta-restrita-nativa.test.js', 'decision-identity.test.js',
+    'codex-controller-sensor.test.js', 'consulta-restrita-nativa.test.js', 'decision-identity.test.js', 'embedding-ponte.test.js',
     'mcp-git.test.js', 'mcp-server.test.js', 'mcp-ship.test.js', 'mcp-verify.test.js',
     'memory-native-preparation.test.js', 'memory-native-schema.test.js', 'memory-prospective.test.js',
     'memory-publication-profile.test.js', 'native-fixture.test.js', 'orkmind-transport.test.js', 'verify-sandbox.test.js',