redmine-context 1.0.0

package/dist/surfaces/tui/screens/issue-detail.js

@@ -0,0 +1,182 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * Tela de detalhe de issue (#31) — substitui o placeholder mínimo da #29.
+ *
+ * Carrega a issue completa via `../hooks/use-issue-detail.js`
+ * (`getIssue`+`normalizeIssue` do core, DIRETO — sem passar pelo bundle
+ * Markdown/JSON, que é o formato de saída da CLI/MCP, não o modelo em
+ * memória que esta tela precisa para paginar/rolar o conteúdo). A issue a
+ * buscar vem de `./home-selection.js` (`selectedIssueId`, escrito pela home
+ * ao empilhar esta tela — ver o JSDoc daquele módulo para o porquê de um
+ * contexto compartilhado em vez de props).
+ *
+ * Layout: metadados (status/prioridade/autor/responsável/datas) FIXOS no
+ * topo — nunca rolam — e descrição + histórico de journals dentro de um
+ * `../components/scroll-view.tsx` (viewport de altura fixa,
+ * `j`/`k`/setas/PgUp/PgDn), para que a tela não quebre o layout mesmo com uma
+ * issue com dezenas de journals.
+ *
+ * `Esc` (atalho global, `../app.tsx`) desempilha normalmente — a home é
+ * remontada, mas `selectedIndex` é preservado via `./home-selection.js`
+ * (documentado ali). `b` é o atalho local, mesmo padrão de
+ * `doctor.tsx`/`config.tsx`.
+ *
+ * 401 é responsabilidade de `useAuthGuard`, já embutido em
+ * `use-issue-detail.js` (mandatório, M2-13/#36) — esta tela só formata o
+ * estado `auth-aborted` (neutro) igual aos demais banners de erro.
+ *
+ * Anexos (#32): seção "Anexos" ao FIM do mesmo `ScrollView` — nome, tamanho
+ * humanizado (`../format-file-size.js`) e badge de status
+ * (`../attachment-status.js`); mesma rolagem, sem bloquear navegação.
+ *
+ * `e` (issue carregada) empilha a tela de exportação (#33, `./export.js`):
+ * a issue normalizada é espelhada em `./loaded-issue-context.js` para a
+ * exportação REUSAR a issue em memória (ver JSDoc daquele módulo).
+ */
+import { Box, Text, useInput } from 'ink';
+import { useEffect, useRef } from 'react';
+import { attachmentStatusColor, attachmentStatusLabel, deriveAttachmentExtractionStatus, } from '../attachment-status.js';
+import { Spinner } from '../components/spinner.js';
+import { ScrollView } from '../components/scroll-view.js';
+import { glyphs } from '../glyphs.js';
+import { humanizeFileSize } from '../format-file-size.js';
+import { useIssueDetail } from '../hooks/use-issue-detail.js';
+import { useTerminalHeight } from '../hooks/use-terminal-width.js';
+import { useNavigation } from '../navigation.js';
+import { statusColor } from '../status-color.js';
+import { symbols } from '../symbols.js';
+import { useTheme } from '../theme.js';
+import { useHomeSelection } from './home-selection.js';
+import { useLoadedIssue } from './loaded-issue-context.js';
+/**
+ * Overhead de linhas FORA da viewport de descrição (breadcrumb + título + meta +
+ * rodapé + paddings). A viewport cresce com o terminal: `altura - OVERHEAD`
+ * (#190). Com a altura default dos testes (24) dá 10 — o valor histórico — então
+ * os snapshots/asserções de rolagem seguem iguais; em terminal real a descrição
+ * usa quase toda a tela e só rola quando passa DE VERDADE.
+ */
+const CONTENT_OVERHEAD_ROWS = 14;
+/** Piso da viewport (terminais muito baixos). */
+const CONTENT_MIN_HEIGHT = 6;
+/** Placeholder discreto para campos ausentes (assignee, autor/data de journal, old/new value). ASCII no Windows legado (#84). */
+const EMPTY_PLACEHOLDER = glyphs.emptyPlaceholder;
+/** Metadados fixos no topo: id/subject, status/prioridade, autor/responsável, datas. */
+function IssueMeta({ issue, theme }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: theme.primary, children: ["#", issue.id, " ", issue.subject] }), _jsxs(Box, { children: [_jsxs(Text, { color: statusColor(theme, issue.status.name), children: ["[", issue.status.name, "]"] }), _jsx(Text, { children: " " }), _jsx(Text, { color: theme.accent, children: issue.priority.name })] }), _jsxs(Box, { children: [_jsx(Text, { color: theme.muted, children: "Autor: " }), _jsx(Text, { children: issue.author.name }), _jsx(Text, { color: theme.muted, children: " Respons\u00E1vel: " }), _jsx(Text, { children: issue.assigned_to?.name ?? EMPTY_PLACEHOLDER })] }), _jsxs(Box, { children: [_jsx(Text, { color: theme.muted, children: "Criada em: " }), _jsx(Text, { children: issue.created_on }), _jsx(Text, { color: theme.muted, children: " Atualizada em: " }), _jsx(Text, { children: issue.updated_on })] })] }));
+}
+/** Constrói a linha de um único anexo: nome (texto derivado, puro) · tamanho humanizado · content_type · badge de status. */
+function buildAttachmentRow(attachment, theme) {
+    const status = deriveAttachmentExtractionStatus(attachment);
+    return (_jsxs(Text, { children: [attachment.filename, ' ', _jsxs(Text, { color: theme.muted, children: ["(", humanizeFileSize(attachment.filesize), " ", glyphs.middleDot, " ", attachment.content_type ?? EMPTY_PLACEHOLDER, ")"] }), ' ', _jsxs(Text, { color: attachmentStatusColor(theme, status), children: ["[", attachmentStatusLabel(status), "]"] })] }, `attachment-${attachment.id}`));
+}
+/** Constrói as linhas da seção de anexos (após os journals): cabeçalho + 1 linha por anexo, ou "(nenhum)". */
+function buildAttachmentRows(issue, theme) {
+    const rows = [
+        _jsx(Text, { color: theme.primary, children: "Anexos" }, "attachments-header"),
+    ];
+    if (issue.attachments.length === 0) {
+        rows.push(_jsx(Text, { color: theme.muted, children: "(nenhum)" }, "attachments-empty"));
+    }
+    else {
+        issue.attachments.forEach((attachment) => {
+            rows.push(buildAttachmentRow(attachment, theme));
+        });
+    }
+    return rows;
+}
+/** Constrói as linhas da viewport rolável: bloco de descrição + histórico cronológico de journals. */
+function buildContentRows(issue, theme) {
+    const rows = [];
+    rows.push(_jsx(Text, { color: theme.primary, children: "Descri\u00E7\u00E3o" }, "desc-header"));
+    if (issue.description === undefined || issue.description === '') {
+        rows.push(_jsx(Text, { color: theme.muted, children: "(sem descri\u00E7\u00E3o)" }, "desc-empty"));
+    }
+    else {
+        issue.description.split('\n').forEach((line, index) => {
+            rows.push(_jsx(Text, { children: line.length > 0 ? line : ' ' }, `desc-${index}`));
+        });
+    }
+    rows.push(_jsx(Text, { children: " " }, "desc-spacer"));
+    rows.push(_jsx(Text, { color: theme.primary, children: "Hist\u00F3rico" }, "journals-header"));
+    if (issue.journals.length === 0) {
+        rows.push(_jsx(Text, { color: theme.muted, children: "(nenhuma atualiza\u00E7\u00E3o registrada)" }, "journals-empty"));
+    }
+    else {
+        // Cronológico: preserva a ordem já entregue por `getIssue`/`normalizeIssue`.
+        issue.journals.forEach((journal) => {
+            rows.push(_jsxs(Text, { color: theme.muted, children: [journal.user?.name ?? EMPTY_PLACEHOLDER, " ", glyphs.middleDot, " ", journal.created_on] }, `journal-${journal.id}-head`));
+            if (journal.notes !== undefined && journal.notes !== '') {
+                journal.notes.split('\n').forEach((line, index) => {
+                    rows.push(_jsx(Text, { children: line }, `journal-${journal.id}-note-${index}`));
+                });
+            }
+            // Details estruturais resumidos: `campo: antigo → novo`, sempre em muted.
+            journal.details.forEach((detail, index) => {
+                rows.push(_jsxs(Text, { color: theme.muted, children: ['  ', detail.name, ": ", detail.old_value ?? EMPTY_PLACEHOLDER, " ", symbols.arrowRight, ' ', detail.new_value ?? EMPTY_PLACEHOLDER] }, `journal-${journal.id}-detail-${index}`));
+            });
+            rows.push(_jsx(Text, { children: " " }, `journal-${journal.id}-spacer`));
+        });
+    }
+    rows.push(_jsx(Text, { children: " " }, "journals-attachments-spacer"));
+    // Anexos (#32) SEMPRE por último — após journals, dentro do mesmo ScrollView.
+    rows.push(...buildAttachmentRows(issue, theme));
+    return rows;
+}
+/** Rodapé com os atalhos disponíveis nesta tela. */
+function Footer({ showRetry, showExport }) {
+    const theme = useTheme();
+    return (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.muted, children: [showRetry ? (_jsxs(_Fragment, { children: ["Pressione", ' ', _jsx(Text, { color: theme.accent, children: "r" }), ' ', "para tentar de novo,", ' '] })) : null, showExport ? (_jsxs(_Fragment, { children: ["Pressione", ' ', _jsx(Text, { color: theme.accent, children: "e" }), ' ', "para exportar,", ' '] })) : null, "Pressione", ' ', _jsx(Text, { color: theme.accent, children: "t" }), ' ', "para ver os jobs,", ' ', _jsx(Text, { color: theme.accent, children: "b" }), ' ', "para voltar."] }) }));
+}
+/**
+ * Tela de detalhe: metadados fixos + descrição/journals em viewport rolável.
+ * `b` (ou `Esc`, atalho global) volta para a home — `selectedIndex` da lista
+ * é preservado via `./home-selection.js`.
+ */
+export function IssueDetailScreen() {
+    const { pop, push } = useNavigation();
+    const theme = useTheme();
+    const { selectedIssueId } = useHomeSelection();
+    const { state, retry } = useIssueDetail(selectedIssueId);
+    const { setIssue } = useLoadedIssue();
+    // Viewport de descrição CRESCE com o terminal (#190) — só rola quando o conteúdo
+    // passa da tela de verdade, em vez de uma janelinha fixa com espaço vazio embaixo.
+    const contentHeight = Math.max(CONTENT_MIN_HEIGHT, useTerminalHeight() - CONTENT_OVERHEAD_ROWS);
+    // Espelha a issue carregada no contexto leve consumido por `./export.js`
+    // (#33) — ver o JSDoc do módulo e de `./loaded-issue-context.js` para a
+    // escolha de reuso em memória em vez de refetch.
+    const setIssueRef = useRef(setIssue);
+    setIssueRef.current = setIssue;
+    useEffect(() => {
+        if (state.status === 'loaded') {
+            setIssueRef.current(state.issue);
+        }
+    }, [state]);
+    useInput((input) => {
+        if (input === 'b') {
+            pop();
+            return;
+        }
+        if (input === 'e' && state.status === 'loaded') {
+            push('export');
+            return;
+        }
+        // #34 (M2-11): "t" abre o painel de jobs da sessão (`./jobs.js`) — em
+        // qualquer estado (loading/erro/loaded), sem restrição, ao contrário de
+        // "e" (exportar), que só faz sentido com a issue já carregada.
+        if (input === 't') {
+            push('jobs');
+            return;
+        }
+        if (input === 'r' &&
+            (state.status === 'error-network' ||
+                state.status === 'error-forbidden' ||
+                state.status === 'error-not-found' ||
+                state.status === 'auth-aborted')) {
+            retry();
+        }
+    });
+    return (_jsxs(Box, { flexGrow: 1, flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(Text, { color: theme.primary, children: "Detalhe da issue" }), state.status === 'no-selection' ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.muted, children: "Nenhuma issue selecionada." }) })) : null, state.status === 'loading' ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [_jsx(Spinner, {}), " Carregando issue..."] }) })) : null, state.status === 'error-network' ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.danger, children: [symbols.cross, " Falha ao carregar a issue: ", state.message] }) })) : null, state.status === 'error-forbidden' ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.danger, children: [symbols.cross, " ", state.message] }) })) : null, state.status === 'error-not-found' ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.danger, children: [symbols.cross, " ", state.message] }) })) : null, state.status === 'auth-aborted' ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.muted, children: state.message }) })) : null, state.status === 'loaded' ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(IssueMeta, { issue: state.issue, theme: theme }), _jsx(Box, { marginTop: 1, children: _jsx(ScrollView, { lines: buildContentRows(state.issue, theme), height: contentHeight }) })] })) : null, _jsx(Box, { flexGrow: 1 }), _jsx(Footer, { showRetry: state.status === 'error-network' ||
+                    state.status === 'error-forbidden' ||
+                    state.status === 'error-not-found' ||
+                    state.status === 'auth-aborted', showExport: state.status === 'loaded' })] }));
+}

package/dist/surfaces/tui/screens/jobs.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tela do painel de jobs: lista as operações da sessão (`../job-registry.tsx`),
+ * `↑/↓`/`j`/`k` navegam a seleção, `Ctrl+C` cancela o job selecionado (só se
+ * `cancelable`, ver o JSDoc de `../job-registry.tsx`), `b` (ou `Esc`, atalho
+ * global) volta.
+ */
+export declare function JobsScreen(): import("react").JSX.Element;

package/dist/surfaces/tui/screens/jobs.js

@@ -0,0 +1,89 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Painel de jobs da sessão (#34/M2-11) — empilhado a partir da home
+ * (`./home.tsx`) ou do detalhe (`./issue-detail.tsx`) com a tecla `t`
+ * ("tarefas"), disponível em qualquer estado das duas telas.
+ *
+ * Lista as operações registradas em `../job-registry.tsx` (ver o JSDoc
+ * daquele módulo para o contrato completo) — hoje só a exportação de bundle
+ * (`./export.tsx`, #33) é um produtor real; a tela já está pronta para
+ * qualquer job futuro do M3/M4 sem mudança de contrato.
+ *
+ * ## `ink-task-list`: incompatibilidade verificada, componente próprio
+ *
+ * A AC pedia `ink-task-list` (já na dependência do projeto) OU um componente
+ * próprio "se a lib conflitar com ink@6". Testado manualmente antes de
+ * qualquer implementação (`ink-testing-library` + `ink-task-list@2.0.0`):
+ *
+ * 1. **Sem export default** — só exporta `{ Task, TaskList }` nomeados (o
+ *    típico `import TaskList, { Task } from 'ink-task-list'` sugerido pela
+ *    doc da lib quebra com `ink@6`/ESM estrito).
+ * 2. **Cores hardcoded internas** (amarelo/vermelho/verde/cinza fixos no
+ *    próprio bundle da lib) — incompatível com a AC "cores do tema": a
+ *    varredura anti-hardcode do repo (`tests/surfaces/tui/no-hardcoded-colors.test.ts`)
+ *    só cobre `src/surfaces/tui`, então isso não quebraria o CI, mas o
+ *    resultado visual NUNCA respeitaria um tema customizado — justamente o
+ *    problema que `theme.ts` existe para resolver.
+ * 3. O estado `'loading'` da lib **exige** um prop `spinner` explícito
+ *    (`{ frames, interval }`, sem default) — omiti-lo quebra o render com
+ *    `Cannot read properties of undefined (reading 'frames')`. Contornável
+ *    passando um objeto de frames à mão, mas é mais um sinal de uma lib
+ *    parada na era do ink@3 (suas `devDependencies` fixam `ink@^3.2.0` e
+ *    `react@^17.0.2`).
+ *
+ * Dado o conflito real com a AC de tema (item 2) e a fragilidade do item 3,
+ * a escolha foi um componente próprio, reaproveitando peças já existentes:
+ * `../symbols.ts` (ícones, com fallback ASCII automático) para os estados
+ * estáticos e o `Spinner` (`../components/spinner.tsx`) já usado por
+ * `./export.tsx`/`./home.tsx` para `processing` — ver `../job-status.ts` para
+ * o mapeamento ícone/cor por status.
+ */
+import { Box, Text, useInput } from 'ink';
+import { useRef } from 'react';
+import { Spinner } from '../components/spinner.js';
+import { glyphs } from '../glyphs.js';
+import { useListNavigation } from '../hooks/use-list-navigation.js';
+import { useJobRegistry } from '../job-registry.js';
+import { jobStatusColor, jobStatusIcon, jobStatusLabel } from '../job-status.js';
+import { useNavigation } from '../navigation.js';
+import { symbols } from '../symbols.js';
+import { useTheme } from '../theme.js';
+/** Uma linha do painel: ícone/spinner de status, rótulo, badge textual e, quando selecionada, o hint de cancelamento. */
+function JobRow({ job, selected, theme }) {
+    const icon = jobStatusIcon(job.status);
+    return (_jsxs(Box, { children: [_jsx(Text, { color: theme.primary, children: selected ? `${symbols.pointerSmall} ` : '  ' }), job.status === 'processing' ? (_jsx(Spinner, {})) : (_jsx(Text, { color: jobStatusColor(theme, job.status), children: icon })), _jsx(Text, { children: " " }), _jsx(Text, { ...(selected ? { color: theme.primary } : {}), children: job.label }), _jsxs(Text, { color: theme.muted, children: [" [", jobStatusLabel(job.status), "]"] }), selected ? (_jsxs(Text, { color: theme.muted, children: [' ', job.cancelable === true ? '(Ctrl+C cancela)' : '(não cancelável)'] })) : null] }));
+}
+/**
+ * Tela do painel de jobs: lista as operações da sessão (`../job-registry.tsx`),
+ * `↑/↓`/`j`/`k` navegam a seleção, `Ctrl+C` cancela o job selecionado (só se
+ * `cancelable`, ver o JSDoc de `../job-registry.tsx`), `b` (ou `Esc`, atalho
+ * global) volta.
+ */
+export function JobsScreen() {
+    const theme = useTheme();
+    const { pop } = useNavigation();
+    const { jobs } = useJobRegistry();
+    const { selectedIndex } = useListNavigation(jobs.length);
+    // Handlers ESTÁVEIS (refs + useCallback via closures simples aqui, padrão
+    // do repo): identidade nova a cada render des/re-subscreve o useInput e
+    // pode perder uma tecla rápida entre pressões próximas.
+    const popRef = useRef(pop);
+    popRef.current = pop;
+    const jobsRef = useRef(jobs);
+    jobsRef.current = jobs;
+    const selectedIndexRef = useRef(selectedIndex);
+    selectedIndexRef.current = selectedIndex;
+    useInput((input, key) => {
+        if (input === 'b') {
+            popRef.current();
+            return;
+        }
+        if (key.ctrl && input === 'c') {
+            const selectedJob = jobsRef.current[selectedIndexRef.current];
+            if (selectedJob?.cancelable === true) {
+                selectedJob.onCancel?.();
+            }
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(Text, { color: theme.primary, children: "Jobs da sess\u00E3o" }), jobs.length === 0 ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.muted, children: "Nenhum job nesta sess\u00E3o ainda." }) })) : (_jsx(Box, { marginTop: 1, flexDirection: "column", children: jobs.map((job, index) => (_jsx(JobRow, { job: job, selected: index === selectedIndex, theme: theme }, job.id))) })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.muted, children: [_jsx(Text, { color: theme.accent, children: `${glyphs.arrowUp}/${glyphs.arrowDown}` }), ' ', "navega,", ' ', _jsx(Text, { color: theme.accent, children: "Ctrl+C" }), ' ', "cancela o job selecionado (se cancel\u00E1vel),", ' ', _jsx(Text, { color: theme.accent, children: "b" }), ' ', "volta."] }) })] }));
+}

package/dist/surfaces/tui/screens/loaded-issue-context.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Issue em memória compartilhada entre `./issue-detail.tsx` e `./export.tsx`
+ * (#33), mesmo padrão de `./home-selection.tsx` (contexto leve, instanciado
+ * uma vez em `../app.tsx`, sobrevivendo ao unmount de cada tela).
+ *
+ * ## Por que este contexto existe (escolha de reuso documentada, AC da #33)
+ *
+ * A tela de exportação precisa da MESMA {@link Issue} já carregada pelo
+ * detalhe para empacotar via `buildMarkdownBundle`/`buildJsonBundle`
+ * (`../../../index.js`). Duas opções foram consideradas:
+ *
+ * 1. **Reusar a issue em memória** (escolhida): `./issue-detail.tsx` grava a
+ *    issue aqui assim que `useIssueDetail` resolve para `loaded`; `./export.tsx`
+ *    lê daqui e chama os builders DIRETO — sem HTTP nem normalização de novo.
+ * 2. **Refetch simples**: `./export.tsx` chamaria `fetchIssueBundle` (ou o
+ *    par `getIssue`+`normalizeIssue`) de novo, ignorando que o detalhe acabou
+ *    de buscar a mesma issue segundos antes.
+ *
+ * (1) evita uma segunda chamada de rede redundante (a issue não muda entre o
+ * usuário abrir o detalhe e pressionar `e`) e é consistente com a decisão já
+ * tomada pela #31 de manter o modelo `Issue` em memória em vez de só um bundle
+ * serializado. O roteador (`../app.tsx`) só mantém montado o TOPO da pilha —
+ * ao empilhar `export` a partir do detalhe, `IssueDetailScreen` é desmontada,
+ * então a issue precisa sobreviver em algo ACIMA da pilha, daí o contexto
+ * (mesmo raciocínio do `HomeSelectionProvider`, ver o JSDoc daquele módulo).
+ */
+import { type ReactNode } from 'react';
+import type { Issue } from '../../../index.js';
+/** Valor exposto pelo contexto da issue em memória. */
+export interface LoadedIssueValue {
+    /** Última issue carregada por `./issue-detail.tsx`, ou `undefined` antes de qualquer carga. */
+    issue: Issue | undefined;
+    /** Registra a issue carregada — chamado pelo detalhe assim que `useIssueDetail` resolve para `loaded`. */
+    setIssue: (issue: Issue) => void;
+}
+/**
+ * Provider do contexto de issue em memória — instanciado uma vez em
+ * `../app.tsx`, envolvendo toda a árvore de telas (ver o JSDoc do módulo).
+ */
+export declare function LoadedIssueProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * Hook de issue em memória consumido por `./issue-detail.tsx`/`./export.tsx`.
+ *
+ * @throws {Error} Se chamado fora de um `<LoadedIssueProvider>` — indica erro
+ *   de composição (tela renderizada sem passar pelo roteador).
+ */
+export declare function useLoadedIssue(): LoadedIssueValue;

package/dist/surfaces/tui/screens/loaded-issue-context.js

@@ -0,0 +1,57 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Issue em memória compartilhada entre `./issue-detail.tsx` e `./export.tsx`
+ * (#33), mesmo padrão de `./home-selection.tsx` (contexto leve, instanciado
+ * uma vez em `../app.tsx`, sobrevivendo ao unmount de cada tela).
+ *
+ * ## Por que este contexto existe (escolha de reuso documentada, AC da #33)
+ *
+ * A tela de exportação precisa da MESMA {@link Issue} já carregada pelo
+ * detalhe para empacotar via `buildMarkdownBundle`/`buildJsonBundle`
+ * (`../../../index.js`). Duas opções foram consideradas:
+ *
+ * 1. **Reusar a issue em memória** (escolhida): `./issue-detail.tsx` grava a
+ *    issue aqui assim que `useIssueDetail` resolve para `loaded`; `./export.tsx`
+ *    lê daqui e chama os builders DIRETO — sem HTTP nem normalização de novo.
+ * 2. **Refetch simples**: `./export.tsx` chamaria `fetchIssueBundle` (ou o
+ *    par `getIssue`+`normalizeIssue`) de novo, ignorando que o detalhe acabou
+ *    de buscar a mesma issue segundos antes.
+ *
+ * (1) evita uma segunda chamada de rede redundante (a issue não muda entre o
+ * usuário abrir o detalhe e pressionar `e`) e é consistente com a decisão já
+ * tomada pela #31 de manter o modelo `Issue` em memória em vez de só um bundle
+ * serializado. O roteador (`../app.tsx`) só mantém montado o TOPO da pilha —
+ * ao empilhar `export` a partir do detalhe, `IssueDetailScreen` é desmontada,
+ * então a issue precisa sobreviver em algo ACIMA da pilha, daí o contexto
+ * (mesmo raciocínio do `HomeSelectionProvider`, ver o JSDoc daquele módulo).
+ */
+import { createContext, useCallback, useContext, useState } from 'react';
+const LoadedIssueContext = createContext(undefined);
+/**
+ * Provider do contexto de issue em memória — instanciado uma vez em
+ * `../app.tsx`, envolvendo toda a árvore de telas (ver o JSDoc do módulo).
+ */
+export function LoadedIssueProvider({ children }) {
+    const [issue, setIssueState] = useState(undefined);
+    // Identidade ESTÁVEL (useCallback sem deps, padrão do repo) — evita
+    // resubscrições desnecessárias em quem a usa como dependência de efeito
+    // (ex.: `./issue-detail.tsx`).
+    const setIssue = useCallback((next) => {
+        setIssueState(next);
+    }, []);
+    const value = { issue, setIssue };
+    return _jsx(LoadedIssueContext.Provider, { value: value, children: children });
+}
+/**
+ * Hook de issue em memória consumido por `./issue-detail.tsx`/`./export.tsx`.
+ *
+ * @throws {Error} Se chamado fora de um `<LoadedIssueProvider>` — indica erro
+ *   de composição (tela renderizada sem passar pelo roteador).
+ */
+export function useLoadedIssue() {
+    const value = useContext(LoadedIssueContext);
+    if (value === undefined) {
+        throw new Error('useLoadedIssue() usado fora de <LoadedIssueProvider>.');
+    }
+    return value;
+}

package/dist/surfaces/tui/screens/onboarding/api-key.d.ts

@@ -0,0 +1,2 @@
+/** Tela de onboarding: colar api_key — Enter valida e confirma, Esc volta (atalho global, ver `../../app.tsx`). */
+export declare function OnboardingApiKeyScreen(): import("react").JSX.Element;

package/dist/surfaces/tui/screens/onboarding/api-key.js

@@ -0,0 +1,69 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Tela de onboarding: colar api_key diretamente (#28) — alcançável de dois
+ * jeitos: (1) escolha direta na tela de modo (`mode.tsx`, opção "Colar uma
+ * api_key"), ou (2) fallback automático quando o login por senha falha com
+ * 401/2FA (`validating.tsx` faz `replace('onboarding-api-key')`, ADR-003).
+ *
+ * Campo único mascarado (mesmo `TextInput` do login por senha, `mask="•"` —
+ * a key nunca é ecoada em texto). Ao confirmar, a key é VALIDADA contra
+ * `GET /users/current.json` (via `callbacks.onApiKeySubmit`, wiring real em
+ * `../../hooks/use-onboarding-callbacks.ts`) ANTES de ser persistida —
+ * mesma disciplina do login por senha (nunca salva sem confirmar que a
+ * credencial funciona). Estado assíncrono gerenciado localmente (mesmo
+ * padrão de `../config.tsx` no fluxo de logout): idle → validating → error,
+ * com spinner próprio (`../../components/spinner.tsx`) durante a validação.
+ *
+ * M2-13 (issue #36): esta tela também é o fallback de 2FA (`validating.tsx`,
+ * `replace('onboarding-api-key')`) quando o login por senha de um re-auth
+ * falha com 401 — então o sucesso aqui também precisa checar
+ * `OnboardingContext.reAuth` e, se definido, voltar à tela de origem
+ * (`popTo`) e retomar a operação original (`resolveReAuth()`) em vez de
+ * seguir para a splash.
+ */
+import { Box, Text } from 'ink';
+import { useState } from 'react';
+import { Spinner } from '../../components/spinner.js';
+import { TextInput } from '../../components/text-input.js';
+import { glyphs } from '../../glyphs.js';
+import { useNavigation } from '../../navigation.js';
+import { symbols } from '../../symbols.js';
+import { useTheme } from '../../theme.js';
+import { useOnboarding } from './onboarding-context.js';
+/** Tela de onboarding: colar api_key — Enter valida e confirma, Esc volta (atalho global, ver `../../app.tsx`). */
+export function OnboardingApiKeyScreen() {
+    const theme = useTheme();
+    const { replace, popTo } = useNavigation();
+    const { callbacks, setUser, reAuth, resolveReAuth } = useOnboarding();
+    const [apiKey, setApiKey] = useState('');
+    const [status, setStatus] = useState('idle');
+    const [errorMessage, setErrorMessage] = useState(undefined);
+    function handleSubmit(value) {
+        setStatus('validating');
+        setErrorMessage(undefined);
+        callbacks.onApiKeySubmit(value).then((outcome) => {
+            if (outcome.kind === 'success') {
+                setUser(outcome.user);
+                if (reAuth !== undefined) {
+                    // M2-13 (#36): volta à tela de origem e retoma a operação
+                    // original — ver o mesmo desvio em `validating.tsx`.
+                    popTo(reAuth.origin);
+                    resolveReAuth();
+                    return;
+                }
+                replace('onboarding-success');
+                return;
+            }
+            setStatus('error');
+            setErrorMessage(outcome.message);
+        }, (cause) => {
+            // Reason: defesa em profundidade — `onApiKeySubmit` (ver
+            // `../../hooks/use-onboarding-callbacks.ts`) já converte qualquer
+            // falha num `OnboardingLoginOutcome` resolvido; isso só protege
+            // contra um callback injetado incorretamente (ex.: em teste).
+            setStatus('error');
+            setErrorMessage(cause instanceof Error ? cause.message : String(cause));
+        });
+    }
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, borderStyle: "round", borderColor: theme.border, children: [_jsx(Text, { color: theme.primary, children: "Colar api_key" }), _jsxs(Box, { marginTop: 1, children: [_jsxs(Text, { color: theme.muted, children: [symbols.pointer, " api_key: "] }), _jsx(TextInput, { value: apiKey, onChange: setApiKey, onSubmit: handleSubmit, mask: glyphs.maskBullet, isActive: status !== 'validating' })] }), status === 'validating' ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.primary, children: [_jsx(Spinner, {}), " Validando api_key..."] }) })) : null, status === 'error' && errorMessage !== undefined ? (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.danger, children: [symbols.cross, " ", errorMessage] }) })) : null, _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.muted, children: ["Pressione", ' ', _jsx(Text, { color: theme.accent, children: "Enter" }), ' ', "para confirmar,", ' ', _jsx(Text, { color: theme.accent, children: "Esc" }), ' ', "para voltar."] }) })] }));
+}

package/dist/surfaces/tui/screens/onboarding/login.d.ts

@@ -0,0 +1,2 @@
+/** Tela de onboarding: login por usuário/senha — Esc volta (atalho global, ver `../../app.tsx`). */
+export declare function OnboardingLoginScreen(): import("react").JSX.Element;

package/dist/surfaces/tui/screens/onboarding/login.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Tela de onboarding 3/3: login por usuário e senha (M2-05.1, issue #27).
+ *
+ * Dois campos (`TextInput`, `../../components/text-input.tsx`): usuário com
+ * eco normal, senha mascarada (`mask="•"`, nunca ecoada em texto — ver
+ * `text-input.tsx`). `Tab`/setas alternam o campo ativo — o `useInput()` do
+ * Ink não tem noção de foco, então só um `TextInput` fica `isActive` por
+ * vez, senão a mesma tecla digitaria nos dois campos ao mesmo tempo. Enter
+ * no campo de usuário avança para a senha; Enter na senha confirma o
+ * formulário: dispara `callbacks.onLoginSubmit` (wiring real a
+ * `loginWithPassword` do core em `../../hooks/use-onboarding-callbacks.ts`,
+ * #28), guarda a `Promise` resultante em `pendingLogin` (`OnboardingContext`)
+ * e navega para `onboarding-validating`, que consome essa promise e decide a
+ * próxima tela (splash de sucesso, fallback de api_key em 401/2FA, ou
+ * mensagem de erro de rede).
+ */
+import { Box, Text, useInput } from 'ink';
+import { useState, useCallback } from 'react';
+import { TextInput } from '../../components/text-input.js';
+import { glyphs } from '../../glyphs.js';
+import { useNavigation } from '../../navigation.js';
+import { symbols } from '../../symbols.js';
+import { useTheme } from '../../theme.js';
+import { useOnboarding } from './onboarding-context.js';
+/** Alterna entre os dois campos do formulário. */
+function otherField(field) {
+    return field === 'username' ? 'password' : 'username';
+}
+/** Tela de onboarding: login por usuário/senha — Esc volta (atalho global, ver `../../app.tsx`). */
+export function OnboardingLoginScreen() {
+    const theme = useTheme();
+    const { push } = useNavigation();
+    const { callbacks, setPendingLogin } = useOnboarding();
+    const [username, setUsername] = useState('');
+    const [password, setPassword] = useState('');
+    const [field, setField] = useState('username');
+    // Handler estável — setField (setState) já tem identidade fixa; o useCallback
+    // garante que o useInput subscreva uma única vez (padrão do repo).
+    const handleFieldSwitch = useCallback((_input, key) => {
+        if (key.tab || key.downArrow || key.upArrow) {
+            setField(otherField);
+        }
+    }, []);
+    useInput(handleFieldSwitch);
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, borderStyle: "round", borderColor: theme.border, children: [_jsx(Text, { color: theme.primary, children: "Login no Redmine" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { color: field === 'username' ? theme.primary : theme.muted, children: [field === 'username' ? symbols.pointer : ' ', " Usu\u00E1rio:", ' '] }), _jsx(TextInput, { value: username, onChange: setUsername, onSubmit: () => setField('password'), isActive: field === 'username' })] }), _jsxs(Box, { children: [_jsxs(Text, { color: field === 'password' ? theme.primary : theme.muted, children: [field === 'password' ? symbols.pointer : ' ', " Senha:", ' '] }), _jsx(TextInput, { value: password, onChange: setPassword, onSubmit: () => {
+                                    setPendingLogin(callbacks.onLoginSubmit({ username, password }));
+                                    push('onboarding-validating');
+                                }, mask: glyphs.maskBullet, isActive: field === 'password' })] })] }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.muted, children: [_jsx(Text, { color: theme.accent, children: "Tab" }), ' ', "alterna o campo,", ' ', _jsx(Text, { color: theme.accent, children: "Enter" }), ' ', "confirma,", ' ', _jsx(Text, { color: theme.accent, children: "Esc" }), ' ', "volta."] }) })] }));
+}

package/dist/surfaces/tui/screens/onboarding/mode.d.ts

@@ -0,0 +1,2 @@
+/** Tela de onboarding: modo de autenticação — setas/`j`/`k` navegam, Enter confirma, Esc volta (atalho global, ver `../../app.tsx`). */
+export declare function OnboardingModeScreen(): import("react").JSX.Element;

package/dist/surfaces/tui/screens/onboarding/mode.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Tela de onboarding 2/3: modo de autenticação (M2-05.1, issue #27).
+ *
+ * Seleção entre login por usuário/senha (avança para `onboarding-login`) e
+ * colar uma api_key diretamente (avança para `onboarding-api-key`, #28).
+ * `useListNavigation` (M2-04) dá o teclado padrão de lista (setas/`j`/`k`/
+ * Enter) de graça — nenhuma reimplementação aqui.
+ */
+import { Box, Text } from 'ink';
+import { glyphs } from '../../glyphs.js';
+import { useListNavigation } from '../../hooks/use-list-navigation.js';
+import { useNavigation } from '../../navigation.js';
+import { symbols } from '../../symbols.js';
+import { useTheme } from '../../theme.js';
+import { useOnboarding } from './onboarding-context.js';
+/** As duas formas de autenticação suportadas pelo onboarding. */
+const MODE_OPTIONS = [
+    { mode: 'password', label: 'Entrar com usuário e senha' },
+    { mode: 'api-key', label: 'Colar uma api_key' },
+];
+/** Tela de onboarding: modo de autenticação — setas/`j`/`k` navegam, Enter confirma, Esc volta (atalho global, ver `../../app.tsx`). */
+export function OnboardingModeScreen() {
+    const { push } = useNavigation();
+    const theme = useTheme();
+    const { setMode, callbacks } = useOnboarding();
+    const { selectedIndex } = useListNavigation(MODE_OPTIONS.length, {
+        onSelect: (index) => {
+            const option = MODE_OPTIONS[index];
+            if (option === undefined) {
+                return;
+            }
+            setMode(option.mode);
+            callbacks.onModeSelect(option.mode);
+            push(option.mode === 'password' ? 'onboarding-login' : 'onboarding-api-key');
+        },
+    });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, borderStyle: "round", borderColor: theme.border, children: [_jsx(Text, { color: theme.primary, children: "Como voc\u00EA quer entrar?" }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: MODE_OPTIONS.map((option, index) => {
+                    const isSelected = index === selectedIndex;
+                    return (_jsxs(Text, { color: isSelected ? theme.primary : theme.muted, children: [isSelected ? symbols.pointer : ' ', " ", option.label] }, option.mode));
+                }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.muted, children: [_jsx(Text, { color: theme.accent, children: `${glyphs.arrowUp}${glyphs.arrowDown}/j/k` }), ' ', "navegam,", ' ', _jsx(Text, { color: theme.accent, children: "Enter" }), ' ', "confirma,", ' ', _jsx(Text, { color: theme.accent, children: "Esc" }), ' ', "volta."] }) })] }));
+}