@neetru/cli 2.29.0 → 2.32.0

package/dist/commands/bug.d.ts

@@ -1,3 +1,61 @@
+interface BugRow {
+    id: string;
+    title?: string;
+    status?: string;
+    severity?: string;
+    category?: string;
+    assignedTo?: string;
+    productId?: string;
+    reportedAt?: unknown;
+    updatedAt?: unknown;
+    reportedBy?: {
+        actorType?: string;
+        actorId?: string;
+        email?: string;
+    };
+    description?: string;
+    reproductionSteps?: string;
+    expectedBehavior?: string;
+    actualBehavior?: string;
+    resolution?: {
+        summary?: string;
+        commitSha?: string;
+        resolvedBy?: string;
+        resolvedAt?: unknown;
+    };
+    comments?: Array<{
+        author: string;
+        body: string;
+        at?: unknown;
+    }>;
+    environment?: {
+        cliVersion?: string;
+        sdkVersion?: string;
+        nodeVersion?: string;
+        os?: string;
+    };
+}
+/**
+ * Limpa o que o usuário colou: espaços, reticências da tabela antiga, caixa
+ * alta, e aceita o hex sem o `bug_` na frente (`a4f84c1b` → `bug_a4f84c1b`).
+ */
+export declare function normalizarEntradaDeId(entrada: string): string;
+export type ResolucaoDeIdDeBug = {
+    ok: true;
+    id: string;
+} | {
+    ok: false;
+    motivo: 'curto_demais' | 'nao_encontrado' | 'ambiguo';
+    candidatos: BugRow[];
+};
+/** Pura: decide o id a partir da entrada e da lista. Testável sem rede. */
+export declare function escolherBugPorPrefixo(entrada: string, rows: BugRow[]): ResolucaoDeIdDeBug;
+/**
+ * Resolve o id que o usuário digitou pro id completo. Id completo não custa
+ * chamada extra; prefixo custa UMA listagem. Falha sai com mensagem que diz o
+ * que fazer, em vez do "não encontrado" que mentia.
+ */
+export declare function resolverIdDoBug(entrada: string, token: string, json?: boolean): Promise<string>;
 export interface BugReportOptions {
     title?: string;
     body?: string;
@@ -85,3 +143,4 @@ export interface BugCommentOptions {
  *   neetru bug comment bug_abc123 --body "Testei em Node 22 — reproduzível."
  */
 export declare function runBugComment(id: string, opts: BugCommentOptions): Promise<void>;
+export {};

package/dist/commands/bug.js

@@ -21,6 +21,108 @@ import { printWriteResult } from '../lib/cli-write.js';
 import { renderTable, fmtTimestamp } from '../lib/render.js';
 import { log } from '../utils/logger.js';
 import { safeExit } from '../utils/safe-exit.js';
+// ─── Id do bug: inteiro na tela, prefixo como atalho ─────────────────────────
+//
+// bug_a4f84c1b (2026-10-12): o id que o Core gera tem 36 caracteres
+// (`bug_` + uuid sem hífen) e a tabela cortava em 24 com `…`. O usuário copiava
+// o que via, e `bug show` respondia "não encontrado" — negando a EXISTÊNCIA de
+// um bug que existe. O próprio Dev Core caiu nisso consultando bug_a8375858.
+//
+// A tabela mostra o id INTEIRO: é o único handle que funciona sempre. A primeira
+// versão deste conserto mostrava um id curto (`bug_` + 8 hex), e a revisão
+// independente reproduziu em produção o defeito de novo: numa listagem filtrada
+// (`--status resolved`), 38 de 200 linhas estavam fora da janela que a resolução
+// de prefixo enxerga — a tabela imprimia de novo um handle que não resolvia.
+//
+// O prefixo continua aceito como ATALHO, pra quem digita ou cola o que o time
+// escreve no chat (`bug_a4f84c1b`). Ambíguo lista candidatos; não achado NUNCA
+// afirma que o bug não existe — só que não estava no que a listagem devolveu.
+/** Formato do id gerado pelo Core (`bug_${randomUUID().replace(/-/g, '')}`). */
+const ID_COMPLETO = /^bug_[0-9a-f]{32}$/;
+/** Mínimo de hex depois de `bug_` pra aceitar como prefixo. */
+const PREFIXO_MINIMO = 4;
+/** Teto do `?limit` da listagem no Core (`cli/v1/bugs/route.ts`). */
+const LIMITE_DA_LISTAGEM = 200;
+/**
+ * Limpa o que o usuário colou: espaços, reticências da tabela antiga, caixa
+ * alta, e aceita o hex sem o `bug_` na frente (`a4f84c1b` → `bug_a4f84c1b`).
+ */
+export function normalizarEntradaDeId(entrada) {
+    let s = entrada.trim().toLowerCase();
+    s = s.replace(/(…|\.\.\.)$/, '');
+    if (!s.startsWith('bug_') && /^[0-9a-f]+$/.test(s))
+        s = `bug_${s}`;
+    return s;
+}
+/** Pura: decide o id a partir da entrada e da lista. Testável sem rede. */
+export function escolherBugPorPrefixo(entrada, rows) {
+    const alvo = normalizarEntradaDeId(entrada);
+    if (ID_COMPLETO.test(alvo))
+        return { ok: true, id: alvo };
+    if (alvo.length < 'bug_'.length + PREFIXO_MINIMO) {
+        return { ok: false, motivo: 'curto_demais', candidatos: [] };
+    }
+    const candidatos = rows.filter((r) => typeof r.id === 'string' && r.id.startsWith(alvo));
+    if (candidatos.length === 1)
+        return { ok: true, id: candidatos[0].id };
+    return {
+        ok: false,
+        motivo: candidatos.length === 0 ? 'nao_encontrado' : 'ambiguo',
+        candidatos,
+    };
+}
+/**
+ * Resolve o id que o usuário digitou pro id completo. Id completo não custa
+ * chamada extra; prefixo custa UMA listagem. Falha sai com mensagem que diz o
+ * que fazer, em vez do "não encontrado" que mentia.
+ */
+export async function resolverIdDoBug(entrada, token, json) {
+    const direto = normalizarEntradaDeId(entrada);
+    if (ID_COMPLETO.test(direto))
+        return direto;
+    let rows = [];
+    try {
+        const res = await apiRequest(`/api/cli/v1/bugs?limit=${LIMITE_DA_LISTAGEM}`, { token });
+        rows = Array.isArray(res?.reports) ? res.reports : [];
+    }
+    catch (error) {
+        handleApiError(error, json);
+    }
+    const r = escolherBugPorPrefixo(entrada, rows);
+    if (r.ok)
+        return r.id;
+    let msg;
+    if (r.motivo === 'curto_demais') {
+        msg =
+            `Id "${entrada}" curto demais. Use ao menos bug_ + ${PREFIXO_MINIMO} caracteres ` +
+                '(ex.: bug_a4f8) ou o id completo de `neetru bug list --json`.';
+    }
+    else if (r.motivo === 'ambiguo') {
+        const lista = r.candidatos
+            .slice(0, 10)
+            .map((b) => `  ${b.id}  ${b.title ?? ''}`.trimEnd())
+            .join('\n');
+        msg = `Prefixo "${entrada}" casa com ${r.candidatos.length} bugs — use mais caracteres:\n${lista}`;
+    }
+    else {
+        // NUNCA afirmar que o bug não existe: a listagem tem teto (200) e, pra quem
+        // não é admin, ainda é filtrada por produto no Core. O que dá pra afirmar é
+        // só o que foi visto.
+        msg =
+            `Não achei bug começando com "${direto}" entre os ${rows.length} que a ` +
+                'listagem devolveu (os mais recentes que você pode ver). Use o id completo — ' +
+                'a coluna ID de `neetru bug list` mostra inteiro.';
+    }
+    if (json) {
+        // Mesmo formato do resto da CLI (`cli-write.ts`): `error` é o CÓDIGO, em texto.
+        console.log(JSON.stringify({ ok: false, error: `bug_id_${r.motivo}`, message: msg }));
+    }
+    else {
+        log.error(msg);
+    }
+    safeExit(1);
+    return '';
+}
 // ─── Formatação ──────────────────────────────────────────────────────────────
 function colorStatus(s) {
     if (!s)
@@ -187,12 +289,14 @@ export async function runBugList(opts) {
         return;
     }
     renderTable([
-        { header: 'ID', value: (b) => b.id, maxWidth: 24 },
+        { header: 'ID', value: (b) => b.id, identificador: true },
         { header: 'TÍTULO', value: (b) => b.title ?? '—', maxWidth: 40 },
         { header: 'STATUS', value: (b) => colorStatus(b.status) },
         { header: 'SEV', value: (b) => colorSeverity(b.severity) },
         { header: 'CATEGORIA', value: (b) => b.category ?? '—', maxWidth: 10 },
-        { header: 'RESPONSÁVEL', value: (b) => b.assignedTo ?? chalk.dim('—'), maxWidth: 24 },
+        // uid de 28 caracteres que `--assigned-to` aceita de volta: cortado em 24
+        // virava um uid que não existe (revisão do #75).
+        { header: 'RESPONSÁVEL', value: (b) => b.assignedTo ?? chalk.dim('—'), identificador: true },
         { header: 'REPORTADO', value: (b) => fmtTimestamp(b.reportedAt), maxWidth: 14 },
     ], res.reports);
     console.log();
@@ -209,6 +313,7 @@ export async function runBugShow(id, opts) {
         safeExit(1);
     }
     const token = await requireToken(opts.json);
+    id = await resolverIdDoBug(id, token, opts.json);
     const spinner = opts.json ? null : ora({ text: `Buscando bug ${id}…`, color: 'blue' }).start();
     let res;
     try {
@@ -286,6 +391,7 @@ export async function runBugClaim(id, opts) {
         safeExit(1);
     }
     const token = await requireToken(opts.json);
+    id = await resolverIdDoBug(id, token, opts.json);
     const spinner = opts.json ? null : ora({ text: `Assumindo bug ${id}…`, color: 'blue' }).start();
     let res;
     try {
@@ -352,6 +458,11 @@ export async function runBugResolve(id, opts) {
         safeExit(1);
     }
     const token = await requireToken(opts.json);
+    id = await resolverIdDoBug(id, token, opts.json);
+    // `--duplicate-of` também é id de bug: sem resolver, o Core gravaria a
+    // duplicata apontando pra um id que não existe.
+    if (duplicateOf)
+        duplicateOf = await resolverIdDoBug(duplicateOf, token, opts.json);
     const spinner = opts.json ? null : ora({ text: `Encerrando bug ${id}…`, color: 'blue' }).start();
     let res;
     try {
@@ -401,6 +512,7 @@ export async function runBugComment(id, opts) {
         safeExit(1);
     }
     const token = await requireToken(opts.json);
+    id = await resolverIdDoBug(id, token, opts.json);
     const spinner = opts.json ? null : ora({ text: `Comentando bug ${id}…`, color: 'blue' }).start();
     let res;
     try {

package/dist/commands/build.d.ts

@@ -1,5 +1,17 @@
+import { type RuntimeEnvironmentId } from '../lib/envs.js';
 export interface BuildOptions {
     product?: string;
+    /**
+     * bug_678ddc98: diretório do APP a construir, relativo a onde o comando foi
+     * invocado. Em monorepo (pnpm workspaces + Turborepo) o app não fica na raiz
+     * do repo — antes disso só dava pra buildar com `cd apps/web`, o que levava
+     * junto o `.neetru-build` e a resolução de lockfile pro lugar errado.
+     *
+     * O artefato continua saindo onde o comando foi invocado (a raiz do repo, em
+     * geral) pra que o `neetru deploy` seguinte, que procura
+     * `<cwd>/.neetru-build/manifest.json`, encontre o que acabou de ser gerado.
+     */
+    app?: string;
     /**
      * Stack a usar no build. 'nextjs' é alias de conveniência da CLI — normalizado
      * pra 'node' internamente (bug_ebac4e6c: antes causava "Stack desconhecida: nextjs").
@@ -34,7 +46,7 @@ export interface BuildOptions {
      * spawn-env (que dotenv/Next.js NUNCA sobrescreve a partir de arquivo)
      * — neutraliza o arquivo ambiente sem tocar em nada no disco do dev.
      */
-    targetEnv?: 'dev' | 'workspace' | 'prod';
+    targetEnv?: RuntimeEnvironmentId;
     /**
      * SETOR 5.1 (PLANO_MESTRE_QUALIDADE_ECOSSISTEMA_2026-08-03): saída
      * machine-readable. Suprime banner/spinner/logs humanos do stdout, roteia a
@@ -62,6 +74,17 @@ export interface BuildManifest {
     sha256: string;
     sizeBytes: number;
     entrypoint?: string;
+    /**
+     * Prefixo do app dentro do standalone, quando o Next.js ANINHOU o app num
+     * monorepo (`apps/web`). `''`/ausente = app na raiz do tarball, layout que o
+     * agente sabe inferir sozinho.
+     *
+     * Existe pra o `deploy` conseguir distinguir "entrypoint que o agente NÃO tem
+     * como adivinhar" de "entrypoint que ele adivinha melhor que a gente" — ver
+     * `entrypointParaDeploy` em `deploy.ts`. Sem este campo o deploy teria que
+     * inferir o aninhamento do formato da string, inferência sobre inferência.
+     */
+    appPrefix?: string;
     builtAt: string;
 }
 /**