primocode 11.1.0 → 11.3.0

package/lib/projetos-meta.js

@@ -0,0 +1,107 @@
+// Projetos do app: pasta em ~/primocode/<projeto>/ + .primocode/projeto.json
+// (nome, descrição, ícone, cor). docs/estrutura.md, seção 7. Node puro.
+// "Apagar" só arquiva (marca no projeto.json): os arquivos da pessoa nunca são removidos.
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const ICONES = ['folder', 'film', 'palette', 'workflow', 'pen', 'home', 'shield', 'bell', 'sliders', 'code', 'rocket', 'cake', 'store', 'clapperboard', 'megaphone', 'graduation-cap', 'heart', 'camera', 'music'];
+const COR_PADRAO = '#22d3ee';
+const hexOk = (h) => /^#[0-9a-f]{6}$/i.test(String(h || ''));
+const cfg = () => require('./config/config');
+const raiz = () => cfg().ROOT_DIR;
+const metaDe = (dir) => path.join(dir, '.primocode', 'projeto.json');
+
+function lerMeta(dir) { try { return JSON.parse(fs.readFileSync(metaDe(dir), 'utf8')); } catch { return {}; } }
+function gravarMeta(dir, meta) {
+    fs.mkdirSync(path.join(dir, '.primocode'), { recursive: true });
+    fs.writeFileSync(metaDe(dir), JSON.stringify(meta, null, 2) + '\n');
+}
+
+/* id = nome da pasta. Só vale se a pasta existe dentro da raiz. */
+function pastaDe(id) {
+    const s = String(id || '');
+    if (!/^[\w][\w.-]{0,80}$/.test(s)) return null;
+    const dir = path.join(raiz(), s);
+    try { return fs.statSync(dir).isDirectory() ? dir : null; } catch { return null; }
+}
+
+/* Se a pasta é um repositório git, devolve { git: true, ramo }: lido do .git/HEAD, sem rodar o git. */
+function ramoGit(dir) {
+    try {
+        const cabeca = fs.readFileSync(path.join(dir, '.git', 'HEAD'), 'utf8').trim();
+        const m = /^ref: refs\/heads\/(.+)$/.exec(cabeca);
+        return { git: true, ramo: m ? m[1] : cabeca.slice(0, 7) };
+    } catch { return { git: false, ramo: '' }; }
+}
+
+/* O "dono/repo" do remoto origin, lido do .git/config (sem rodar o git). Vazio se não há. */
+function remotoGit(dir) {
+    try {
+        const cfg = fs.readFileSync(path.join(dir, '.git', 'config'), 'utf8');
+        const m = /\[remote "origin"\][^\[]*?url\s*=\s*(\S+)/.exec(cfg);
+        const r = m && /[:/]([\w.-]+\/[\w.-]+?)(?:\.git)?$/.exec(m[1]);
+        return r ? r[1] : '';
+    } catch { return ''; }
+}
+
+/* Quantos itens (arquivos e pastas, sem os ocultos) o projeto tem na raiz, e quando mexeram nele por último. */
+function conteudo(dir) {
+    try { return { itens: fs.readdirSync(dir).filter((n) => !n.startsWith('.')).length, atualizado: fs.statSync(dir).mtimeMs }; } catch { return { itens: 0, atualizado: null }; }
+}
+
+function resumo(id) {
+    const dir = path.join(raiz(), id);
+    const m = lerMeta(dir);
+    return {
+        id, nome: m.nome || id, descricao: m.descricao || '',
+        icone: ICONES.includes(m.icone) ? m.icone : 'folder', cor: hexOk(m.cor) ? m.cor : COR_PADRAO,
+        caminho: dir, arquivado: !!m.arquivado, criado: m.criado || null,
+        ...ramoGit(dir), remoto: remotoGit(dir), ...conteudo(dir),
+    };
+}
+
+function listar({ arquivados = false } = {}) {
+    /* O mais recente primeiro (como a lista da barra lateral); empate por nome. */
+    return cfg().listProjects().map(resumo).filter((p) => arquivados || !p.arquivado)
+        .sort((a, b) => String(b.criado || '').localeCompare(String(a.criado || '')) || a.nome.localeCompare(b.nome));
+}
+
+function limpar(c, { criando = false } = {}) {
+    const out = {};
+    if ('nome' in c) { out.nome = String(c.nome || '').trim().slice(0, 80); if (!out.nome) throw new Error('falta o nome'); }
+    else if (criando) throw new Error('falta o nome');
+    if ('descricao' in c) out.descricao = String(c.descricao || '').trim().slice(0, 240);
+    if ('icone' in c && c.icone) { if (!ICONES.includes(c.icone)) throw new Error(`ícone inválido (use: ${ICONES.join(', ')})`); out.icone = c.icone; }
+    if ('cor' in c && c.cor) { if (!hexOk(c.cor)) throw new Error('cor inválida (use #rrggbb)'); out.cor = String(c.cor).toLowerCase(); }
+    return out;
+}
+
+function criar(c = {}) {
+    const campos = limpar(c, { criando: true });
+    const dir = cfg().createProjectDir(campos.nome);
+    const id = path.basename(dir);
+    const atual = lerMeta(dir);
+    if (atual.nome && !atual.arquivado) throw new Error(`já existe o projeto "${atual.nome}"`);
+    gravarMeta(dir, { ...atual, ...campos, arquivado: false, criado: atual.criado || new Date().toISOString() });
+    return resumo(id);
+}
+
+function atualizar(id, c = {}) {
+    const dir = pastaDe(id);
+    if (!dir) throw new Error(`não achei o projeto ${id}`);
+    const campos = limpar(c);
+    if (!Object.keys(campos).length) throw new Error('nada para mudar (nome, descricao, icone, cor)');
+    gravarMeta(dir, { ...lerMeta(dir), ...campos });
+    return resumo(path.basename(dir));
+}
+
+function arquivar(id) {
+    const dir = pastaDe(id);
+    if (!dir) throw new Error(`não achei o projeto ${id}`);
+    gravarMeta(dir, { ...lerMeta(dir), arquivado: true });
+    return { id: path.basename(dir), arquivado: true, arquivos: 'mantidos' };
+}
+
+module.exports = { ICONES, listar, criar, atualizar, arquivar, pastaDe, resumo };

package/lib/qr.js

@@ -0,0 +1,209 @@
+// Gerador de QR code mínimo, sem dependência: modo byte (UTF-8), correção L ou M, versões 1 a 10
+// (até 213 bytes no M, 271 no L). Serve para o pareamento do celular (docs/estrutura.md, seção 15).
+// Algoritmo da ISO/IEC 18004: Reed-Solomon em GF(256), 8 máscaras, escolhe a de menor penalidade.
+'use strict';
+
+const ECC_POR_BLOCO = { L: [7, 10, 15, 20, 26, 18, 20, 24, 30, 18], M: [10, 16, 26, 18, 24, 16, 18, 22, 22, 26] };
+const NUM_BLOCOS = { L: [1, 1, 1, 1, 1, 2, 2, 2, 2, 4], M: [1, 1, 1, 2, 2, 4, 4, 4, 5, 5] };
+const FORMATO_ECC = { L: 1, M: 0 };
+const VERSAO_MAX = 10;
+
+/* Módulos que sobram para dados + correção, descontados padrões de função. */
+function modulosBrutos(v) {
+    let r = (16 * v + 128) * v + 64;
+    if (v >= 2) {
+        const n = Math.floor(v / 7) + 2;
+        r -= (25 * n - 10) * n - 55;
+        if (v >= 7) r -= 36;
+    }
+    return r;
+}
+const dadosCodewords = (v, ecc) => Math.floor(modulosBrutos(v) / 8) - ECC_POR_BLOCO[ecc][v - 1] * NUM_BLOCOS[ecc][v - 1];
+
+/* GF(256) com o polinômio 0x11D. */
+function multiplicar(x, y) {
+    let z = 0;
+    for (let i = 7; i >= 0; i--) { z = (z << 1) ^ ((z >>> 7) * 0x11D); z ^= ((y >>> i) & 1) * x; }
+    return z;
+}
+function divisor(grau) {
+    const r = new Array(grau).fill(0);
+    r[grau - 1] = 1;
+    let raiz = 1;
+    for (let i = 0; i < grau; i++) {
+        for (let j = 0; j < r.length; j++) { r[j] = multiplicar(r[j], raiz); if (j + 1 < r.length) r[j] ^= r[j + 1]; }
+        raiz = multiplicar(raiz, 2);
+    }
+    return r;
+}
+function resto(dados, div) {
+    const r = new Array(div.length).fill(0);
+    for (const b of dados) {
+        const f = b ^ r.shift();
+        r.push(0);
+        div.forEach((c, i) => { r[i] ^= multiplicar(c, f); });
+    }
+    return r;
+}
+
+function bitsDoTexto(bytes, v, ecc) {
+    const bits = [];
+    const poe = (valor, n) => { for (let i = n - 1; i >= 0; i--) bits.push((valor >>> i) & 1); };
+    poe(0b0100, 4);
+    poe(bytes.length, v <= 9 ? 8 : 16);
+    for (const b of bytes) poe(b, 8);
+    const cap = dadosCodewords(v, ecc) * 8;
+    poe(0, Math.min(4, cap - bits.length));
+    poe(0, (8 - (bits.length % 8)) % 8);
+    for (let pad = 0xEC; bits.length < cap; pad ^= 0xEC ^ 0x11) poe(pad, 8);
+    const cw = [];
+    for (let i = 0; i < bits.length; i += 8) cw.push(parseInt(bits.slice(i, i + 8).join(''), 2));
+    return cw;
+}
+
+/* Divide em blocos, calcula a correção e intercala. */
+function intercalar(dados, v, ecc) {
+    const nb = NUM_BLOCOS[ecc][v - 1];
+    const eb = ECC_POR_BLOCO[ecc][v - 1];
+    const total = Math.floor(modulosBrutos(v) / 8);
+    const curtos = nb - (total % nb);
+    const lenCurto = Math.floor(total / nb) - eb;
+    const div = divisor(eb);
+    const blocos = [];
+    for (let i = 0, k = 0; i < nb; i++) {
+        const dat = dados.slice(k, k + lenCurto + (i < curtos ? 0 : 1));
+        k += dat.length;
+        blocos.push({ dat, ecc: resto(dat, div) });
+    }
+    const out = [];
+    for (let i = 0; i <= lenCurto; i++) for (const b of blocos) if (i < b.dat.length) out.push(b.dat[i]);
+    for (let i = 0; i < eb; i++) for (const b of blocos) out.push(b.ecc[i]);
+    return out;
+}
+
+function criarMatriz(v) {
+    const n = v * 4 + 17;
+    return { n, m: Array.from({ length: n }, () => new Array(n).fill(false)), f: Array.from({ length: n }, () => new Array(n).fill(false)) };
+}
+function posAlinhamento(v) {
+    if (v === 1) return [];
+    const n = Math.floor(v / 7) + 2;
+    const passo = v === 32 ? 26 : Math.ceil((v * 4 + 4) / (n * 2 - 2)) * 2;
+    const r = [6];
+    for (let p = v * 4 + 10; r.length < n; p -= passo) r.splice(1, 0, p);
+    return r;
+}
+function desenharFuncoes(Q, v, ecc) {
+    const { n, m, f } = Q;
+    const set = (x, y, cor) => { if (x >= 0 && x < n && y >= 0 && y < n) { m[y][x] = cor; f[y][x] = true; } };
+    for (let i = 0; i < n; i++) { set(6, i, i % 2 === 0); set(i, 6, i % 2 === 0); }
+    const busca = (cx, cy) => { for (let dy = -4; dy <= 4; dy++) for (let dx = -4; dx <= 4; dx++) { const d = Math.max(Math.abs(dx), Math.abs(dy)); set(cx + dx, cy + dy, d !== 2 && d !== 4); } };
+    busca(3, 3); busca(n - 4, 3); busca(3, n - 4);
+    const al = posAlinhamento(v);
+    for (let i = 0; i < al.length; i++) for (let j = 0; j < al.length; j++) {
+        if ((i === 0 && j === 0) || (i === 0 && j === al.length - 1) || (i === al.length - 1 && j === 0)) continue;
+        for (let dy = -2; dy <= 2; dy++) for (let dx = -2; dx <= 2; dx++) set(al[i] + dx, al[j] + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+    }
+    desenharFormato(Q, ecc, 0);
+    if (v >= 7) {
+        let r = v;
+        for (let i = 0; i < 12; i++) r = (r << 1) ^ ((r >>> 11) * 0x1F25);
+        const bits = (v << 12) | r;
+        for (let i = 0; i < 18; i++) {
+            const cor = ((bits >>> i) & 1) !== 0;
+            const a = n - 11 + (i % 3);
+            const b = Math.floor(i / 3);
+            set(a, b, cor); set(b, a, cor);
+        }
+    }
+}
+function desenharFormato(Q, ecc, mascara) {
+    const { n, m, f } = Q;
+    const dados = (FORMATO_ECC[ecc] << 3) | mascara;
+    let r = dados;
+    for (let i = 0; i < 10; i++) r = (r << 1) ^ ((r >>> 9) * 0x537);
+    const bits = ((dados << 10) | r) ^ 0x5412;
+    const bit = (i) => ((bits >>> i) & 1) !== 0;
+    const set = (x, y, cor) => { m[y][x] = cor; f[y][x] = true; };
+    for (let i = 0; i <= 5; i++) set(8, i, bit(i));
+    set(8, 7, bit(6)); set(8, 8, bit(7)); set(7, 8, bit(8));
+    for (let i = 9; i < 15; i++) set(14 - i, 8, bit(i));
+    for (let i = 0; i < 8; i++) set(n - 1 - i, 8, bit(i));
+    for (let i = 8; i < 15; i++) set(8, n - 15 + i, bit(i));
+    set(8, n - 8, true);
+}
+function colocarDados(Q, cw) {
+    const { n, m, f } = Q;
+    let i = 0;
+    for (let direita = n - 1; direita >= 1; direita -= 2) {
+        if (direita === 6) direita = 5;
+        for (let vert = 0; vert < n; vert++) for (let j = 0; j < 2; j++) {
+            const x = direita - j;
+            const y = ((direita + 1) & 2) === 0 ? n - 1 - vert : vert;
+            if (!f[y][x] && i < cw.length * 8) { m[y][x] = ((cw[i >>> 3] >>> (7 - (i & 7))) & 1) !== 0; i++; }
+        }
+    }
+}
+const MASCARAS = [
+    (x, y) => (x + y) % 2 === 0, (x, y) => y % 2 === 0, (x) => x % 3 === 0, (x, y) => (x + y) % 3 === 0,
+    (x, y) => (Math.floor(x / 3) + Math.floor(y / 2)) % 2 === 0, (x, y) => ((x * y) % 2) + ((x * y) % 3) === 0,
+    (x, y) => (((x * y) % 2) + ((x * y) % 3)) % 2 === 0, (x, y) => (((x + y) % 2) + ((x * y) % 3)) % 2 === 0,
+];
+function aplicarMascara(Q, k) {
+    for (let y = 0; y < Q.n; y++) for (let x = 0; x < Q.n; x++) if (!Q.f[y][x] && MASCARAS[k](x, y)) Q.m[y][x] = !Q.m[y][x];
+}
+function penalidade(Q) {
+    const { n, m } = Q;
+    let p = 0;
+    const corrida = (linha) => {
+        let s = 0; let run = 1;
+        for (let i = 1; i <= linha.length; i++) {
+            if (i < linha.length && linha[i] === linha[i - 1]) run++;
+            else { if (run >= 5) s += run - 2; run = 1; }
+        }
+        const str = linha.map((b) => (b ? 1 : 0)).join('');
+        for (const pad of ['10111010000', '00001011101']) { let at = str.indexOf(pad); while (at >= 0) { s += 40; at = str.indexOf(pad, at + 1); } }
+        return s;
+    };
+    for (let y = 0; y < n; y++) p += corrida(m[y]);
+    for (let x = 0; x < n; x++) p += corrida(m.map((l) => l[x]));
+    for (let y = 0; y < n - 1; y++) for (let x = 0; x < n - 1; x++) if (m[y][x] === m[y][x + 1] && m[y][x] === m[y + 1][x] && m[y][x] === m[y + 1][x + 1]) p += 3;
+    const escuros = m.reduce((a, l) => a + l.filter(Boolean).length, 0);
+    p += (Math.ceil(Math.abs(escuros * 20 - n * n * 10) / (n * n)) - 1) * 10;
+    return p;
+}
+
+/* Devolve { tamanho, modulos: boolean[][], versao }. Lança se o texto não cabe. */
+function gerarQR(texto, { ecc = 'M' } = {}) {
+    if (!ECC_POR_BLOCO[ecc]) throw new Error('ecc deve ser L ou M');
+    const bytes = Buffer.from(String(texto), 'utf8');
+    let v = 1;
+    for (; v <= VERSAO_MAX; v++) {
+        const bitsLen = 4 + (v <= 9 ? 8 : 16) + bytes.length * 8;
+        if (bitsLen <= dadosCodewords(v, ecc) * 8) break;
+    }
+    if (v > VERSAO_MAX) throw new Error(`texto grande demais para o QR (${bytes.length} bytes; máximo ${dadosCodewords(VERSAO_MAX, ecc) - 3})`);
+    const cw = intercalar(bitsDoTexto(bytes, v, ecc), v, ecc);
+    let melhor = null;
+    for (let k = 0; k < 8; k++) {
+        const Q = criarMatriz(v);
+        desenharFuncoes(Q, v, ecc);
+        colocarDados(Q, cw);
+        aplicarMascara(Q, k);
+        desenharFormato(Q, ecc, k);
+        const pen = penalidade(Q);
+        if (!melhor || pen < melhor.pen) melhor = { pen, Q };
+    }
+    return { tamanho: melhor.Q.n, modulos: melhor.Q.m, versao: v };
+}
+
+/* SVG pronto (módulos escuros em `cor`, fundo em `fundo`, com a zona de silêncio de 4 módulos). */
+function qrSvg(texto, { ecc = 'M', cor = '#000', fundo = '#fff' } = {}) {
+    const { tamanho, modulos } = gerarQR(texto, { ecc });
+    const t = tamanho + 8;
+    let d = '';
+    for (let y = 0; y < tamanho; y++) for (let x = 0; x < tamanho; x++) if (modulos[y][x]) d += `M${x + 4} ${y + 4}h1v1h-1z`;
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${t} ${t}" shape-rendering="crispEdges" role="img" aria-label="QR code de pareamento"><rect width="${t}" height="${t}" fill="${fundo}"/><path d="${d}" fill="${cor}"/></svg>`;
+}
+
+module.exports = { gerarQR, qrSvg };