@pasosdejesus/m 0.18.0 → 0.18.2

package/dist/tasks/req.js

@@ -0,0 +1,1199 @@
+// src/tasks/req.ts
+// req:* commands — manage cross-project requirements from REQ/ directory.
+// Compares local REQ/*.md files with remote GitLab/GitHub issues,
+// syncs in both directions, and detects cross-project impact.
+import { readFile, writeFile, readdir, stat } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { execSync } from 'node:child_process';
+import { success, problem, info } from '../util/colors.js';
+import { createTranslator } from '../i18n/createTranslator.js';
+import { detectLocale } from '../util/locale.js';
+const reqT = createTranslator(detectLocale(), {
+    en: {
+        'col.type': 'Type',
+        'col.title': 'Title',
+        'col.status': 'Status',
+        'compare.col_type': 'Type',
+        'compare.col_title': 'Title',
+        'compare.col_local': 'Loc.',
+        'compare.col_remote': 'Rem.',
+        'compare.col_sync': 'Sync',
+        'compare.sync_legend': 'Sync: sync=synchronized  loc+=local more recent  rem+=remote more recent  \u2014=one side only',
+        'compare.no_issues': 'No remote issues or local REQs found.',
+        'compare.remote_count': '{{0}} local, {{1}} remote ({{2}} open), {{3}} remote-only.',
+        'compare.remote_only_hint': 'Use req:sync-from-repo <N> to pull them locally.',
+        'compare.identical': '\u2705 Local REQ and remote issue are identical.',
+        'compare.diff_lines': 'Diffs: {{0}} lines.',
+    },
+    es: {
+        'col.type': 'Tipo',
+        'col.title': 'Título',
+        'col.status': 'Estado',
+        'compare.col_type': 'Tipo',
+        'compare.col_title': 'Título',
+        'compare.col_local': 'Loc.',
+        'compare.col_remote': 'Rem.',
+        'compare.col_sync': 'Sinc',
+        'compare.sync_legend': 'Sinc: sync=sincronizados  loc+=local m\u00e1s reciente  rem+=remoto m\u00e1s reciente  \u2014=solo un lado',
+        'compare.no_issues': 'No hay issues remotos ni REQs locales.',
+        'compare.remote_count': '{{0}} locales, {{1}} remotos ({{2}} abiertos), {{3}} solo-remotos.',
+        'compare.remote_only_hint': 'Usa req:sync-from-repo <N> para traerlos localmente.',
+        'compare.identical': '\u2705 REQ local y issue remoto son id\u00e9nticos.',
+        'compare.diff_lines': 'Diferencias: {{0}} l\u00edneas.',
+    },
+});
+const CWD = process.cwd();
+// ── Helpers ─────────────────────────────────────────────
+async function findReqDir() {
+    // Search for REQ/ directory from CWD up to project root
+    let dir = CWD;
+    while (true) {
+        const reqPath = join(dir, 'REQ');
+        if (existsSync(reqPath) && (await readdir(reqPath)).some(f => f.match(/^\d+\.md$/))) {
+            return reqPath;
+        }
+        const parent = resolve(dir, '..');
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return join(CWD, 'REQ');
+}
+function parseReqFile(content, number) {
+    const lines = content.split('\n');
+    // ── Header: # TYPE-#N: Title ─────────────────────
+    let title = '';
+    let issueType = 'R';
+    const firstLine = lines[0] || '';
+    const headerMatch = firstLine.match(/^#\s*([RFIPE])-#(\d+):?\s*(.*)/);
+    if (headerMatch) {
+        issueType = headerMatch[1];
+        title = headerMatch[3]?.trim().replace(/`/g, '') || '';
+        // Strip any embedded old prefix (e.g., "I-#1 Titulo" → "Titulo")
+        title = title.replace(/^[RFIPE]-#\d+:\s*/, '');
+    }
+    // ── Fallback: old YAML frontmatter ───────────────
+    if (!title && lines[0]?.trim() === '---') {
+        const endIdx = lines.slice(1).findIndex(l => l.trim() === '---');
+        if (endIdx > 0) {
+            for (let i = 1; i < endIdx + 1; i++) {
+                const titleMatch = lines[i].match(/^title:\s*"?(.+?)"?\s*$/);
+                if (titleMatch) {
+                    title = titleMatch[1]
+                        .replace(/^[RFIPE]-#\d+:\s*/, '')
+                        .replace(/`/g, '')
+                        .trim();
+                }
+            }
+        }
+    }
+    // ── Fallback: old format first-line ──────────────
+    if (!title) {
+        const oldMatch = firstLine.match(/^(?:#\s*)?[RFIPE]-#\d+\s*(.*)/);
+        if (oldMatch) {
+            title = (oldMatch[1] || '').trim().replace(/`/g, '');
+        }
+    }
+    // ── Fallback: any line with title: ───────────────
+    if (!title) {
+        for (const line of lines) {
+            const m = line.match(/^title:\s*"?(.+?)"?\s*$/);
+            if (m) {
+                title = m[1].replace(/^[RFIPE]-#\d+:\s*/, '').replace(/`/g, '').trim();
+                break;
+            }
+        }
+    }
+    // ── Fallback: derive from first line ──────────────
+    if (!title) {
+        // Use whatever is after # TYPE-#N in the first line, or just "Requerimiento #N"
+        const bare = firstLine.replace(/^#\s*/, '').trim();
+        title = bare || `${issueType}-#${number}`;
+    }
+    // ── Status ───────────────────────────────────────
+    let status = '—';
+    for (let i = 0; i < lines.length; i++) {
+        const s = lines[i].match(/^\*\*Status:\*\*\s*(.+)/);
+        if (s) {
+            status = s[1].trim()
+                .replace(/`/g, '')
+                .replace(/—.*/, '')
+                .trim();
+            break;
+        }
+    }
+    // ── Cross-project ────────────────────────────────
+    const crossProjects = [];
+    for (const line of lines) {
+        const m = line.match(/###\s*🔲\s*Pendiente\s+en\s+`?(\S+?)`?(?:\s|$)/);
+        if (m) {
+            const proj = m[1].replace(/[`']/g, '').replace(/[.,;:]$/, '');
+            if (proj && proj !== 'm' && proj !== '`m`' && !crossProjects.includes(proj)) {
+                crossProjects.push(proj);
+            }
+        }
+    }
+    return { number, type: issueType, title, status, crossProjects };
+}
+async function loadAllReqs(reqDir) {
+    if (!existsSync(reqDir))
+        return [];
+    const files = (await readdir(reqDir))
+        .filter(f => /^\d+\.md$/.test(f))
+        .map(f => parseInt(f.replace('.md', ''), 10))
+        .filter(n => !isNaN(n))
+        .sort((a, b) => a - b);
+    const reqs = [];
+    for (const n of files) {
+        const content = await readFile(join(reqDir, `${n}.md`), 'utf-8');
+        reqs.push(parseReqFile(content, n));
+    }
+    return reqs;
+}
+/**
+ * Translate status to English when LANG=en, keep Spanish otherwise.
+ */
+function translateStatus(status) {
+    if (reqT('col.status') === 'Status') {
+        const map = {
+            'Pendiente': 'Pending',
+            'En progreso': 'In progress',
+            '🔧 En progreso': '🔧 In progress',
+            'Completado': 'Completed',
+            'Bloqueado': 'Blocked',
+            'Cancelado': 'Cancelled',
+        };
+        // Try exact match first, then check if status starts with a known prefix
+        if (map[status])
+            return map[status];
+        for (const [es, en] of Object.entries(map)) {
+            if (status.startsWith(es))
+                return status.replace(es, en);
+        }
+    }
+    return status;
+}
+/**
+ * Parse a list of requirement numbers from args: "1 2 3" or "1,2,3"
+ */
+function parseNumberList(arg) {
+    if (!arg)
+        return [];
+    return arg.split(/[\s,]+/).filter(Boolean).map(Number).filter(n => !isNaN(n) && n > 0);
+}
+// ── req:list ────────────────────────────────────────────
+export async function runReqList() {
+    const reqDir = await findReqDir();
+    const reqs = await loadAllReqs(reqDir);
+    if (reqs.length === 0) {
+        info('No se encontraron requerimientos en REQ/.');
+        return;
+    }
+    const hdrType = reqT('col.type').padEnd(4);
+    const hdrTitle = reqT('col.title').padEnd(34);
+    const hdrStatus = reqT('col.status').padEnd(14);
+    console.log(`   #   │ ${hdrType} │ ${hdrTitle} │ ${hdrStatus}`);
+    console.log(` ──────┼──────┼${'─'.repeat(36)}┼${'─'.repeat(16)}`);
+    for (const r of reqs) {
+        const status = translateStatus(r.status);
+        console.log(`  ${String(r.number).padEnd(4)} │ ${r.type.padEnd(4)} │ ${r.title.slice(0, 34).padEnd(34)} │ ${status.slice(0, 14).padEnd(14)}`);
+    }
+}
+// ── req:show N ──────────────────────────────────────────
+export async function runReqShow(number) {
+    const reqDir = await findReqDir();
+    const filePath = join(reqDir, `${number}.md`);
+    if (!existsSync(filePath)) {
+        problem(`No se encontró REQ/${number}.md`);
+        return;
+    }
+    const content = await readFile(filePath, 'utf-8');
+    console.log(content);
+}
+// ── req:cross ───────────────────────────────────────────
+export async function runReqCross() {
+    const reqDir = await findReqDir();
+    const reqs = await loadAllReqs(reqDir);
+    const cross = reqs.filter(r => r.crossProjects.length > 0);
+    if (cross.length === 0) {
+        info('No se encontraron requerimientos cross-project.');
+        return;
+    }
+    console.log(`   #   │ Título                                      │ Proyectos afectados`);
+    console.log(` ──────┼──────────────────────────────────────────────┼────────────────────`);
+    for (const r of cross) {
+        console.log(`  ${String(r.number).padEnd(4)} │ ${r.title.slice(0, 38).padEnd(38)} │ ${r.crossProjects.join(', ')}`);
+    }
+}
+function parseGitRemote(url) {
+    // SSH: git@gitlab.com:owner/repo.git or git@github.com:owner/repo.git
+    // HTTPS: https://gitlab.com/owner/repo.git or https://github.com/owner/repo.git
+    const sshMatch = url.match(/^git@(gitlab\.com|github\.com):(.+?)(?:\.git)?$/);
+    if (sshMatch) {
+        const host = sshMatch[1];
+        const path = sshMatch[2]; // e.g. "pasosdejesus/m" or "owner/repo"
+        const parts = path.split('/');
+        if (parts.length >= 2) {
+            const owner = parts.slice(0, -1).join('/');
+            const repo = parts[parts.length - 1];
+            if (host === 'gitlab.com') {
+                return { provider: 'gitlab', project: `${owner}/${repo}`, type: 'issue' };
+            }
+            return { provider: 'github', owner, repo };
+        }
+    }
+    const httpsMatch = url.match(/^https:\/\/(gitlab\.com|github\.com)\/(.+?)(?:\.git)?$/);
+    if (httpsMatch) {
+        const host = httpsMatch[1];
+        const path = httpsMatch[2];
+        const parts = path.split('/');
+        if (parts.length >= 2) {
+            const owner = parts.slice(0, -1).join('/');
+            const repo = parts[parts.length - 1];
+            if (host === 'gitlab.com') {
+                return { provider: 'gitlab', project: `${owner}/${repo}`, type: 'issue' };
+            }
+            return { provider: 'github', owner, repo };
+        }
+    }
+    return null;
+}
+async function loadReposConfig() {
+    const configPath = join(homedir(), '.config', 'm', 'req-repos.json');
+    if (existsSync(configPath)) {
+        try {
+            return JSON.parse(await readFile(configPath, 'utf-8'));
+        }
+        catch {
+            // fall through to git remote deduction
+        }
+    }
+    // Fallback: deduce from git remote origin
+    try {
+        const remoteUrl = execSync('git remote get-url origin', {
+            encoding: 'utf-8',
+            cwd: CWD,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        if (remoteUrl) {
+            const deduced = parseGitRemote(remoteUrl);
+            if (deduced)
+                return { m: deduced };
+        }
+    }
+    catch {
+        // git not available or no remote
+    }
+    return {};
+}
+/**
+ * Resuelve la configuración del repo actual combinando:
+ * 1. `req-repos.json` — busca entrada que coincida con el repo actual
+ * 2. `git remote get-url origin` — fallback deducido
+ *
+ * Si req-repos.json tiene una entrada cuyo repo/project coincide con
+ * el nombre del repo deducido de git remote, usa esa entrada (permite
+ * override de provider, e.g. sivel3 con mirror GitLab → issues GitHub).
+ */
+async function getCurrentRepoConfig() {
+    const repos = await loadReposConfig();
+    // Deduce current repo from git remote
+    let deduced = null;
+    try {
+        const remoteUrl = execSync('git remote get-url origin', {
+            encoding: 'utf-8',
+            cwd: CWD,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        deduced = parseGitRemote(remoteUrl);
+    }
+    catch {
+        // git not available
+    }
+    // If we have req-repos.json, try to match the current repo
+    if (deduced) {
+        const deducedName = deduced.repo || deduced.project?.split('/').pop();
+        for (const [key, cfg] of Object.entries(repos)) {
+            const cfgName = cfg.repo || cfg.project?.split('/').pop();
+            if (cfgName && deducedName && cfgName.toLowerCase() === deducedName.toLowerCase()) {
+                return cfg;
+            }
+        }
+    }
+    // Last resort: deduced from git remote
+    return deduced;
+}
+async function readToken(provider) {
+    const home = homedir();
+    if (provider === 'gitlab') {
+        const file = join(home, '.config', 'm', 'gitlab-token');
+        if (existsSync(file))
+            return (await readFile(file, 'utf-8')).trim();
+        return process.env.GITLAB_TOKEN || null;
+    }
+    const file = join(home, '.config', 'm', 'github-token');
+    if (existsSync(file))
+        return (await readFile(file, 'utf-8')).trim();
+    return process.env.GITHUB_TOKEN || null;
+}
+async function fetchRemoteIssue(config, iid, token) {
+    if (config.provider === 'gitlab' && config.project) {
+        const ep = config.type === 'work_item' ? 'issues' : 'issues';
+        const url = `https://gitlab.com/api/v4/projects/${encodeURIComponent(config.project)}/${ep}/${iid}`;
+        const headers = token ? { 'PRIVATE-TOKEN': token } : {};
+        const res = await fetch(url, { headers });
+        if (res.status < 200 || res.status >= 300)
+            throw new Error(`GitLab API error ${res.status}: ${res.statusText}`);
+        return res.json();
+    }
+    if (config.provider === 'github' && config.owner && config.repo) {
+        const url = `https://api.github.com/repos/${config.owner}/${config.repo}/issues/${iid}`;
+        const headers = token ? { Authorization: `token ${token}` } : {};
+        const res = await fetch(url, { headers });
+        if (res.status < 200 || res.status >= 300)
+            throw new Error(`GitHub API error ${res.status}: ${res.statusText}`);
+        return res.json();
+    }
+    throw new Error('Configuración de repositorio incompleta');
+}
+async function fetchRemoteIssueBody(config, iid, token) {
+    try {
+        const issue = await fetchRemoteIssue(config, iid, token);
+        return (issue.body || issue.description || '').toString();
+    }
+    catch {
+        return '';
+    }
+}
+async function updateRemoteIssue(config, iid, title, description, token) {
+    console.log(`[updateRemoteIssue] provider=${config.provider} iid=${iid} title="${title.slice(0, 60)}" descLen=${description.length} tokenLen=${token.length}`);
+    if (config.provider === 'gitlab' && config.project) {
+        const ep = config.type === 'work_item' ? 'issues' : 'issues';
+        const url = `https://gitlab.com/api/v4/projects/${encodeURIComponent(config.project)}/${ep}/${iid}`;
+        console.log(`[updateRemoteIssue] PUT ${url}`);
+        const body = JSON.stringify({ title, description });
+        const { request: httpsRequest } = await import('node:https');
+        const res = await new Promise((resolve, reject) => {
+            const u = new URL(url);
+            const req = httpsRequest({
+                hostname: u.hostname,
+                port: u.port || 443,
+                path: u.pathname + u.search,
+                method: 'PUT',
+                headers: {
+                    'PRIVATE-TOKEN': token,
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(body),
+                },
+            }, (resp) => {
+                let data = '';
+                resp.on('data', (chunk) => data += chunk);
+                resp.on('end', () => resolve({
+                    status: resp.statusCode || 500,
+                    statusText: resp.statusMessage || 'Unknown',
+                    text: async () => data,
+                    json: async () => JSON.parse(data),
+                }));
+            });
+            req.on('error', reject);
+            req.write(body);
+            req.end();
+        });
+        if (res.status < 200 || res.status >= 300) {
+            const text = await res.text();
+            throw new Error(`GitLab API error ${res.status}: ${res.statusText} — ${text.slice(0, 200)}`);
+        }
+        return res.json();
+    }
+    if (config.provider === 'github' && config.owner && config.repo) {
+        const url = `https://api.github.com/repos/${config.owner}/${config.repo}/issues/${iid}`;
+        const body = JSON.stringify({ title, body: description });
+        const { request: httpsRequest } = await import('node:https');
+        const res = await new Promise((resolve, reject) => {
+            const u = new URL(url);
+            const req = httpsRequest({
+                hostname: u.hostname, port: u.port || 443,
+                path: u.pathname + u.search, method: 'PATCH',
+                headers: {
+                    'Authorization': `token ${token}`,
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(body),
+                    'User-Agent': 'm-cli',
+                    'Accept': 'application/vnd.github+json',
+                },
+            }, (resp) => {
+                let data = '';
+                resp.on('data', (chunk) => data += chunk);
+                resp.on('end', () => resolve({
+                    status: resp.statusCode || 500,
+                    statusText: resp.statusMessage || 'Unknown',
+                    text: async () => data,
+                    json: async () => JSON.parse(data),
+                }));
+            });
+            req.on('error', reject);
+            req.write(body);
+            req.end();
+        });
+        if (res.status < 200 || res.status >= 300) {
+            const text = await res.text();
+            throw new Error(`GitHub API error ${res.status}: ${res.statusText} — ${text.slice(0, 200)}`);
+        }
+        return res.json();
+    }
+    throw new Error('Configuración de repositorio incompleta');
+}
+async function fetchRepoIssues(config, token) {
+    if (config.provider === 'gitlab' && config.project) {
+        const ep = config.type === 'work_item' ? 'issues' : 'issues';
+        const url = `https://gitlab.com/api/v4/projects/${encodeURIComponent(config.project)}/${ep}?state=opened&per_page=100`;
+        const headers = token ? { 'PRIVATE-TOKEN': token } : {};
+        const res = await fetch(url, { headers });
+        if (res.status < 200 || res.status >= 300)
+            throw new Error(`GitLab API error ${res.status}: ${res.statusText}`);
+        const issues = await res.json();
+        return issues.map(i => ({
+            iid: i.iid,
+            title: i.title,
+            state: i.state,
+            labels: i.labels || [],
+            web_url: i.web_url || '',
+            updated_at: i.updated_at || null,
+        }));
+    }
+    if (config.provider === 'github' && config.owner && config.repo) {
+        const url = `https://api.github.com/repos/${config.owner}/${config.repo}/issues?state=open&per_page=100`;
+        const headers = token ? { Authorization: `token ${token}` } : {};
+        const res = await fetch(url, { headers });
+        if (res.status < 200 || res.status >= 300)
+            throw new Error(`GitHub API error ${res.status}: ${res.statusText}`);
+        const issues = await res.json();
+        return issues
+            .filter((i) => !i.pull_request) // exclude PRs
+            .map((i) => ({
+            iid: i.number,
+            title: i.title,
+            state: i.state,
+            labels: (i.labels || []).map((l) => l.name),
+            web_url: i.html_url || '',
+            updated_at: i.updated_at || null,
+        }));
+    }
+    throw new Error('Configuración de repositorio incompleta');
+}
+export async function runReqListRepo() {
+    const config = await getCurrentRepoConfig();
+    if (!config) {
+        problem('No se encontró configuración de repositorio. Asegúrate de tener git remote configurado.');
+        return;
+    }
+    const token = await readToken(config.provider);
+    if (!token) {
+        info('[req] Sin token — intentando acceso público (solo lectura).');
+    }
+    try {
+        const issues = await fetchRepoIssues(config, token || '');
+        // Load local REQs for comparison
+        let localNums = new Set();
+        try {
+            const reqDir = await findReqDir();
+            const localReqs = await loadAllReqs(reqDir);
+            localNums = new Set(localReqs.map(r => r.number));
+        }
+        catch {
+            // No local REQs
+        }
+        if (issues.length === 0) {
+            info('No hay issues abiertos en el repositorio remoto.');
+            return;
+        }
+        console.log(`   #   │ Título │ Local │ Labels`);
+        console.log(` ──────┼────────┼───────┼──────`);
+        for (const issue of issues) {
+            const local = localNums.has(issue.iid) ? '✓' : '✗';
+            const labels = issue.labels.slice(0, 3).join(', ');
+            console.log(`  ${String(issue.iid).padEnd(4)}│ ${issue.title.slice(0, 36).padEnd(36)} │  ${local}    │ ${labels}`);
+        }
+        info(`\nTotal: ${issues.length} issues abiertos.`);
+        info(`✓ = tiene REQ local, ✗ = sin REQ local.`);
+    }
+    catch (err) {
+        problem(`Error al listar issues: ${err.message}`);
+    }
+}
+// ── req:compare N / req:compare (all) ──────────────────
+async function runCompareAll(config, token) {
+    try {
+        const issues = await fetchRepoIssues(config, token || '');
+        const reqDir = await findReqDir();
+        const localReqs = await loadAllReqs(reqDir);
+        const localNums = new Set(localReqs.map(r => r.number));
+        // Pre-load local mtimes, content fingerprints, and title format
+        const localMtimeMap = new Map();
+        const localFingerprintMap = new Map();
+        const localHasPrefix = new Map();
+        for (const r of localReqs) {
+            try {
+                const s = await stat(join(reqDir, `${r.number}.md`));
+                localMtimeMap.set(r.number, s.mtime);
+                const content = await readFile(join(reqDir, `${r.number}.md`), 'utf-8');
+                const normalized = content.trim().replace(/\r/g, '').replace(/\n{3,}/g, '\n\n');
+                localFingerprintMap.set(r.number, `${normalized.length}:${normalized.slice(0, 200)}`);
+                // Check if local REQ has proper R-#N: / F-#N: / I-#N: / P-#N: title format
+                localHasPrefix.set(r.number, /^#\s*[RFIPE]-#\d+:/.test(content));
+            }
+            catch {
+                // file inaccessible
+            }
+        }
+        if (issues.length === 0 && localReqs.length === 0) {
+            info(reqT('compare.no_issues'));
+            return;
+        }
+        const titleW = 34;
+        const stateW = 4;
+        const localW = 5;
+        const colType = reqT('compare.col_type'); // Tipo  / Type
+        const colTitle = reqT('compare.col_title'); // Título / Title
+        const colLocal = reqT('compare.col_local'); // Loc.
+        const colRemote = reqT('compare.col_remote'); // Rem.
+        const colSync = reqT('compare.col_sync'); // Sinc / Sync
+        const hdr = `   #   │ ${colType.padEnd(4)} │ ${colTitle.padEnd(titleW)} │ ${colLocal.padEnd(localW)} │ ${colRemote.padEnd(stateW)} │ ${colSync.padEnd(4)}`;
+        const sep = hdr.replace(/[^│]/g, '─').replace(/│/g, '┼');
+        console.log(hdr);
+        console.log(sep);
+        function shortState(s) {
+            if (s === 'opened' || s === 'open')
+                return 'open';
+            if (s === 'closed')
+                return 'clsd';
+            return s.slice(0, stateW);
+        }
+        // Sort issues by iid for consistent display
+        issues.sort((a, b) => a.iid - b.iid);
+        // Show remote issues (with local status)
+        const shown = new Set();
+        for (const issue of issues) {
+            const hasLocal = localNums.has(issue.iid);
+            const localReq = localReqs.find(r => r.number === issue.iid);
+            const typeMatch = issue.title.match(/^([RFIPE])-#[?\d]/);
+            const issueType = (hasLocal && localReq) ? localReq.type : (typeMatch ? typeMatch[1] : 'R');
+            shown.add(issue.iid);
+            let sync = '—';
+            if (hasLocal && issue.updated_at) {
+                const localMtime = localMtimeMap.get(issue.iid);
+                if (localMtime) {
+                    const diffMs = new Date(issue.updated_at).getTime() - localMtime.getTime();
+                    const absMin = Math.abs(Math.round(diffMs / 60000));
+                    if (absMin < 1) {
+                        sync = 'sync';
+                    }
+                    else {
+                        // Check content fingerprint — if identical, it's synced regardless of timestamp
+                        const localFp = localFingerprintMap.get(issue.iid);
+                        const remoteBody = (await fetchRemoteIssueBody(config, issue.iid, token)).trim()
+                            .replace(/\r/g, '').replace(/\n{3,}/g, '\n\n');
+                        const remoteFp = `${remoteBody.length}:${remoteBody.slice(0, 200)}`;
+                        if (localFp && localFp === remoteFp) {
+                            sync = 'sync';
+                        }
+                        else if (diffMs > 0) {
+                            sync = 'rem+';
+                        }
+                        else {
+                            sync = 'loc+';
+                        }
+                        // Title format check: if local has R-#N: prefix and remote doesn't, local wins
+                        if (sync === 'sync' && localHasPrefix.get(issue.iid)) {
+                            const remoteHasPrefix = /^[RFIPE]-#[?\d]+:/.test(issue.title);
+                            if (!remoteHasPrefix)
+                                sync = 'loc+';
+                        }
+                    }
+                }
+            }
+            const displayTitle = issue.title.replace(/^[RFIPE]-#[?\d]+:?\s*/, '').replace(/`/g, '').trim();
+            console.log(`  ${String(issue.iid).padEnd(4)} │ ${issueType.padEnd(4)} │ ${displayTitle.slice(0, titleW).padEnd(titleW)} │ ${hasLocal ? '  ✓' : '  ✗'}   │ ${shortState(issue.state).padEnd(stateW)} │ ${sync}`);
+        }
+        // Show local-only REQs (not in remote open issues)
+        // Try to fetch individually — they might be closed
+        for (const r of localReqs) {
+            if (!shown.has(r.number)) {
+                let remoteState = '—';
+                let remoteTitle = '';
+                let sync = '—';
+                let remoteUpdatedAt = null;
+                try {
+                    const issue = await fetchRemoteIssue(config, r.number, token);
+                    remoteState = issue.state || 'unknown';
+                    remoteTitle = (issue.title || '').replace(/^[RFIPE]-#[?\d]+:?\s*/, '').trim();
+                    remoteUpdatedAt = issue.updated_at || issue.updatedAt || null;
+                    shown.add(r.number);
+                    if (remoteUpdatedAt) {
+                        const localMtime = localMtimeMap.get(r.number);
+                        if (localMtime) {
+                            const diffMs = new Date(remoteUpdatedAt).getTime() - localMtime.getTime();
+                            const absMin = Math.abs(Math.round(diffMs / 60000));
+                            if (absMin < 1) {
+                                sync = 'sync';
+                            }
+                            else {
+                                const localFp = localFingerprintMap.get(r.number);
+                                const remoteBody = (await fetchRemoteIssueBody(config, r.number, token)).trim()
+                                    .replace(/\r/g, '').replace(/\n{3,}/g, '\n\n');
+                                const remoteFp = `${remoteBody.length}:${remoteBody.slice(0, 200)}`;
+                                if (localFp && localFp === remoteFp) {
+                                    sync = 'sync';
+                                }
+                                else if (diffMs > 0) {
+                                    sync = 'rem+';
+                                }
+                                else {
+                                    sync = 'loc+';
+                                }
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Issue doesn't exist remotely
+                }
+                // Title format check: if local has prefix and remote doesn't, local wins
+                if (sync === 'sync' && localHasPrefix.get(r.number)) {
+                    const remoteHasPrefix = /^[RFIPE]-#[?\d]+:/.test(remoteTitle || '');
+                    if (!remoteHasPrefix && remoteState !== '—')
+                        sync = 'loc+';
+                }
+                const title = remoteTitle || r.title;
+                console.log(`  ${String(r.number).padEnd(4)} │ ${r.type.padEnd(4)} │ ${title.slice(0, titleW).padEnd(titleW)} │   ✓   │ ${shortState(remoteState).padEnd(stateW)} │ ${sync}`);
+            }
+        }
+        const localCount = localNums.size;
+        const remoteCount = shown.size;
+        const remoteOnly = [...shown].filter(n => !localNums.has(n)).length;
+        info(`\n${reqT('compare.remote_count', String(localReqs.length), String(remoteCount), String(issues.length), String(remoteOnly))}`);
+        info(reqT('compare.sync_legend'));
+        if (remoteOnly > 0) {
+            info(reqT('compare.remote_only_hint'));
+        }
+    }
+    catch (err) {
+        problem(`Error al comparar: ${err.message}`);
+    }
+}
+export async function runReqCompare(number) {
+    const config = await getCurrentRepoConfig();
+    if (!config) {
+        problem('No se encontró configuración de repositorio. Asegúrate de tener git remote configurado.');
+        return;
+    }
+    const token = await readToken(config.provider);
+    if (!token) {
+        info('[req] Sin token — intentando acceso público (solo lectura).');
+    }
+    // ── No number: compare all ─────────────────────
+    if (number === undefined) {
+        return runCompareAll(config, token);
+    }
+    // ── Single number: compare one ─────────────────
+    const reqDir = await findReqDir();
+    const filePath = join(reqDir, `${number}.md`);
+    if (!existsSync(filePath)) {
+        problem(`No se encontró REQ/${number}.md`);
+        return;
+    }
+    const localContent = await readFile(filePath, 'utf-8');
+    // Diagnostic
+    const apiUrl = config.provider === 'gitlab'
+        ? `https://gitlab.com/api/v4/projects/${encodeURIComponent(config.project)}/issues/${number}`
+        : `https://api.github.com/repos/${config.owner}/${config.repo}/issues/${number}`;
+    info(`[req] provider=${config.provider} url=${apiUrl}`);
+    try {
+        const issue = await fetchRemoteIssue(config, number, token);
+        const remoteDesc = issue.description || issue.body || '';
+        const remoteTitle = (issue.title || '').replace(/^[RFIPE]-#\d+:\s*/, '').trim();
+        const remoteState = issue.state || 'unknown';
+        const remoteUpdatedAt = issue.updated_at || issue.updatedAt || null;
+        // ── Header info ───────────────────────────────
+        const localMeta = parseReqFile(localContent, number);
+        const fileStat = await stat(filePath);
+        const localMtime = fileStat.mtime;
+        console.log(`\n  Local : ${localMeta.type}-#${number}: ${localMeta.title}`);
+        console.log(`  Remoto: #${number}: ${remoteTitle} (${remoteState})`);
+        // ── Date comparison ───────────────────────────
+        console.log(`\n  📅 Local:  ${localMtime.toISOString().replace('T', ' ').slice(0, 19)}`);
+        if (remoteUpdatedAt) {
+            console.log(`  📅 Remoto: ${remoteUpdatedAt}`);
+        }
+        else {
+            console.log(`  📅 Remoto: (desconocida)`);
+        }
+        // ── Sync recommendation ───────────────────────
+        if (remoteUpdatedAt) {
+            const remoteDate = new Date(remoteUpdatedAt);
+            const diffMs = remoteDate.getTime() - localMtime.getTime();
+            const diffMin = Math.round(diffMs / 60000);
+            const absMin = Math.abs(diffMin);
+            if (absMin < 1) {
+                console.log(`\n  ⏱️  Diferencia: < 1 minuto — efectivamente sincronizados.`);
+            }
+            else if (diffMs > 0) {
+                const ago = absMin < 60 ? `${absMin} min` : absMin < 1440 ? `${Math.round(absMin / 60)} h` : `${Math.round(absMin / 1440)} d`;
+                console.log(`\n  ⬇️  Remoto ${ago} más reciente → considera: req:sync-from-repo ${number}`);
+            }
+            else {
+                const ago = absMin < 60 ? `${absMin} min` : absMin < 1440 ? `${Math.round(absMin / 60)} h` : `${Math.round(absMin / 1440)} d`;
+                console.log(`\n  ⬆️  Local ${ago} más reciente → considera: req:sync-to-repo ${number}`);
+            }
+        }
+        // ── Simple diff ───────────────────────────────
+        const localLines = localContent.split('\n');
+        const remoteLines = remoteDesc.split('\n');
+        const maxLen = Math.max(localLines.length, remoteLines.length);
+        let diffs = 0;
+        // Compare titles (body diff below ignores the header line)
+        if (localMeta.title !== remoteTitle) {
+            diffs++;
+            console.log(`- title: ${remoteTitle}`);
+            console.log(`+ title: ${localMeta.title}`);
+        }
+        for (let i = 0; i < maxLen; i++) {
+            const l = localLines[i] || '';
+            const r = remoteLines[i] || '';
+            if (l !== r) {
+                diffs++;
+                if (l)
+                    console.log(`- ${l}`);
+                if (r)
+                    console.log(`+ ${r}`);
+            }
+        }
+        if (diffs === 0) {
+            success('\n✅ REQ local y issue remoto son idénticos.');
+        }
+        else {
+            console.log(`\n  Diferencias: ${diffs} líneas.`);
+        }
+    }
+    catch (err) {
+        problem(`Error al comparar: ${err.message}`);
+    }
+}
+// ── req:sync-from-repo N ────────────────────────────────
+export async function runReqSyncFromRepo(arg) {
+    const numbers = parseNumberList(arg);
+    if (numbers.length === 0) {
+        problem('Uso: req:sync-from-repo <N> [N2 N3 ...]');
+        return;
+    }
+    for (const number of numbers) {
+        info(`Procesando #${number}...`);
+        await syncFromRepoOne(number);
+    }
+    success(`✅ ${numbers.length} requerimiento(s) procesado(s).`);
+}
+async function syncFromRepoOne(number) {
+    const reqDir = await findReqDir();
+    const config = await getCurrentRepoConfig();
+    if (!config) {
+        problem('No se encontró configuración de repositorio. Asegúrate de tener git remote configurado.');
+        return;
+    }
+    const token = await readToken(config.provider);
+    if (!token) {
+        info('[req] Sin token — intentando acceso público (solo lectura).');
+    }
+    try {
+        const issue = await fetchRemoteIssue(config, number, token);
+        const rawBody = issue.description || issue.body || '';
+        const issueTitle = (issue.title || '').replace(/^[RFIPE]-#\d+:\s*/, '').replace(/`/g, '').trim();
+        const issueTypeMatch = (issue.title || '').match(/^([RFIPE])-#\d+:/);
+        const issueType = issueTypeMatch ? issueTypeMatch[1] : 'R';
+        const status = issue.state === 'closed' ? 'Cerrado' : 'Pendiente';
+        const createdAt = (issue.created_at || issue.createdAt || new Date().toISOString()).slice(0, 10);
+        // Build content: use raw body if it already has our header, otherwise wrap
+        let content;
+        if (rawBody.trimStart().match(/^(?:---|#\s*[RFIPE]-#)/)) {
+            content = rawBody;
+        }
+        else {
+            content = `# ${issueType}-#${number}: ${issueTitle}
+
+${rawBody || issueTitle}
+
+---
+
+**Created:** ${createdAt}
+**Status:** ${status}
+`;
+        }
+        const filePath = join(reqDir, `${number}.md`);
+        if (existsSync(filePath)) {
+            // Existing file: backup then overwrite
+            const bakPath = `${filePath}.bak`;
+            await writeFile(bakPath, await readFile(filePath, 'utf-8'));
+            info(`Respaldo creado: ${bakPath}`);
+            await writeFile(filePath, content);
+            success(`✅ REQ/${number}.md actualizado desde el repositorio remoto.`);
+        }
+        else {
+            // New file: create from remote
+            await writeFile(filePath, content);
+            success(`✅ REQ/${number}.md creado desde issue remoto #${number}.`);
+        }
+    }
+    catch (err) {
+        problem(`Error al sincronizar: ${err.message}`);
+    }
+}
+async function createRemoteIssue(config, title, description, token) {
+    if (config.provider === 'gitlab' && config.project) {
+        const ep = config.type === 'work_item' ? 'issues' : 'issues';
+        const url = `https://gitlab.com/api/v4/projects/${encodeURIComponent(config.project)}/${ep}`;
+        const body = JSON.stringify({ title, description });
+        const { request: httpsRequest } = await import('node:https');
+        const res = await new Promise((resolve, reject) => {
+            const u = new URL(url);
+            const req = httpsRequest({
+                hostname: u.hostname, port: u.port || 443,
+                path: u.pathname + u.search, method: 'POST',
+                headers: {
+                    'PRIVATE-TOKEN': token, 'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(body),
+                },
+            }, (resp) => {
+                let data = '';
+                resp.on('data', (chunk) => data += chunk);
+                resp.on('end', () => resolve({
+                    status: resp.statusCode || 500,
+                    statusText: resp.statusMessage || 'Unknown',
+                    text: async () => data,
+                    json: async () => JSON.parse(data),
+                }));
+            });
+            req.on('error', reject);
+            req.write(body);
+            req.end();
+        });
+        if (res.status < 200 || res.status >= 300) {
+            const text = await res.text();
+            throw new Error(`GitLab API error ${res.status}: ${res.statusText} — ${text.slice(0, 200)}`);
+        }
+        return res.json();
+    }
+    if (config.provider === 'github' && config.owner && config.repo) {
+        const url = `https://api.github.com/repos/${config.owner}/${config.repo}/issues`;
+        const body = JSON.stringify({ title, body: description });
+        const { request: httpsRequest } = await import('node:https');
+        const res = await new Promise((resolve, reject) => {
+            const u = new URL(url);
+            const req = httpsRequest({
+                hostname: u.hostname, port: u.port || 443,
+                path: u.pathname + u.search, method: 'POST',
+                headers: {
+                    'Authorization': `token ${token}`,
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(body),
+                    'User-Agent': 'm-cli',
+                    'Accept': 'application/vnd.github+json',
+                },
+            }, (resp) => {
+                let data = '';
+                resp.on('data', (chunk) => data += chunk);
+                resp.on('end', () => resolve({
+                    status: resp.statusCode || 500,
+                    statusText: resp.statusMessage || 'Unknown',
+                    text: async () => data,
+                    json: async () => JSON.parse(data),
+                }));
+            });
+            req.on('error', reject);
+            req.write(body);
+            req.end();
+        });
+        if (res.status < 200 || res.status >= 300) {
+            const text = await res.text();
+            throw new Error(`GitHub API error ${res.status}: ${res.statusText} — ${text.slice(0, 200)}`);
+        }
+        return res.json();
+    }
+    throw new Error('Configuración de repositorio incompleta');
+}
+// ── req:sync-to-repo N ──────────────────────────────────
+export async function runReqSyncToRepo(arg) {
+    const numbers = parseNumberList(arg);
+    if (numbers.length === 0) {
+        problem('Uso: req:sync-to-repo <N> [N2 N3 ...]');
+        return;
+    }
+    for (const number of numbers) {
+        info(`Procesando #${number}...`);
+        await syncToRepoOne(number);
+    }
+    success(`✅ ${numbers.length} requerimiento(s) procesado(s).`);
+}
+async function syncToRepoOne(number) {
+    const reqDir = await findReqDir();
+    const filePath = join(reqDir, `${number}.md`);
+    if (!existsSync(filePath)) {
+        problem(`No se encontró REQ/${number}.md`);
+        return;
+    }
+    const config = await getCurrentRepoConfig();
+    if (!config) {
+        problem('No se encontró configuración de repositorio. Asegúrate de tener git remote configurado.');
+        return;
+    }
+    const token = await readToken(config.provider);
+    if (!token) {
+        problem('No se encontró token. Configúralo en ~/.config/m/github-token o variable GITHUB_TOKEN');
+        return;
+    }
+    const localContent = await readFile(filePath, 'utf-8');
+    const meta = parseReqFile(localContent, number);
+    console.log(`[sync-to-repo] title="${meta.title}" type=${meta.type}`);
+    console.log(`[sync-to-repo] provider=${config.provider} project=${config.project || config.owner + '/' + config.repo}`);
+    console.log(`[sync-to-repo] firstLine=${localContent.split('\n')[0]?.substring(0, 80)}`);
+    try {
+        // Try to update existing issue
+        try {
+            const meta = parseReqFile(localContent, number);
+            const fullTitle = `${meta.type}-#${number}: ${meta.title}`;
+            await updateRemoteIssue(config, number, fullTitle, localContent, token);
+            success(`✅ Issue remoto #${number} actualizado desde REQ/${number}.md.`);
+        }
+        catch (updateErr) {
+            if (updateErr.message?.includes('404')) {
+                // Issue doesn't exist — create it
+                const meta = parseReqFile(localContent, number);
+                const newIssue = await createRemoteIssue(config, `${meta.type}-#?: ${meta.title}`, localContent, token);
+                const remoteIid = newIssue.iid || newIssue.number;
+                info(`✅ Issue creado en remoto como #${remoteIid}.`);
+                if (remoteIid && remoteIid !== number) {
+                    // Rename local file to match remote IID
+                    const newPath = join(reqDir, `${remoteIid}.md`);
+                    const { rename } = await import('node:fs/promises');
+                    let newContent = localContent.replace(new RegExp(`([RFIPE])-#${number}\\b`, 'g'), `$1-#${remoteIid}`);
+                    await writeFile(newPath, newContent);
+                    const { unlink } = await import('node:fs/promises');
+                    await unlink(filePath);
+                    info(`📝 REQ renumerado: ${number}.md → ${remoteIid}.md`);
+                }
+            }
+            else {
+                throw updateErr;
+            }
+        }
+    }
+    catch (err) {
+        problem(`Error al sincronizar: ${err.message}`);
+    }
+}
+// ── req:create "título" ─────────────────────────────────
+export async function runReqCreate(title, typeArg) {
+    if (!title) {
+        problem('Uso: req:create "título" [tipo]  — tipo: R (req), F (falla), I (investigación), P (prueba). Default: R');
+        return;
+    }
+    // Type: first char of typeArg if it's R/F/I/P, otherwise default to R
+    let issueType = 'R';
+    if (typeArg) {
+        const t = typeArg.toUpperCase().charAt(0);
+        if (['R', 'F', 'I', 'P'].includes(t)) {
+            issueType = t;
+        }
+        else {
+            problem(`Tipo inválido: "${typeArg}". Use R, F, I o P.`);
+            return;
+        }
+    }
+    const config = await getCurrentRepoConfig();
+    if (!config) {
+        problem('No se encontró configuración de repositorio. Asegúrate de tener git remote configurado.');
+        return;
+    }
+    const token = await readToken(config.provider);
+    if (!token) {
+        problem('No se encontró token. Configúralo en ~/.config/m/github-token o variable GITHUB_TOKEN');
+        return;
+    }
+    try {
+        // 1. Create remote issue first — repo assigns the IID
+        const fullTitle = `${issueType}-#?: ${title}`;
+        const desc = `${title}\n`;
+        const newIssue = await createRemoteIssue(config, fullTitle, desc, token);
+        const remoteIid = newIssue.iid || newIssue.number;
+        if (!remoteIid)
+            throw new Error('No se pudo obtener el IID del issue creado');
+        // 1b. Update title replacing #? with the assigned IID
+        try {
+            const correctTitle = `${issueType}-#${remoteIid}: ${title}`;
+            if (config.provider === 'gitlab' && config.project) {
+                const ep = config.type === 'work_item' ? 'issues' : 'issues';
+                const url = `https://gitlab.com/api/v4/projects/${encodeURIComponent(config.project)}/${ep}/${remoteIid}`;
+                await fetch(url, {
+                    method: 'PUT',
+                    headers: { 'PRIVATE-TOKEN': token, 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ title: correctTitle }),
+                });
+            }
+            else if (config.provider === 'github' && config.owner && config.repo) {
+                const url = `https://api.github.com/repos/${config.owner}/${config.repo}/issues/${remoteIid}`;
+                await fetch(url, {
+                    method: 'PATCH',
+                    headers: { Authorization: `token ${token}`, 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ title: correctTitle }),
+                });
+            }
+        }
+        catch {
+            // Non-critical: title update failed, issue was created with #? placeholder
+        }
+        // 2. Create local REQ with the assigned IID
+        const reqDir = await findReqDir();
+        const filePath = join(reqDir, `${remoteIid}.md`);
+        if (existsSync(filePath)) {
+            problem(`Ya existe REQ/${remoteIid}.md`);
+            return;
+        }
+        const template = `# ${issueType}-#${remoteIid}: ${title}
+
+${title}
+
+---
+
+**Created:** ${new Date().toISOString().slice(0, 10)}
+**Status:** Pendiente
+`;
+        await writeFile(filePath, template);
+        success(`✅ Issue #${remoteIid} creado en remoto y REQ/${remoteIid}.md local.`);
+    }
+    catch (err) {
+        problem(`Error al crear: ${err.message}`);
+    }
+}
+// ── req:close N ─────────────────────────────────────────
+async function closeRemoteIssue(config, iid, title, token) {
+    if (config.provider === 'gitlab' && config.project) {
+        const ep = config.type === 'work_item' ? 'issues' : 'issues';
+        const url = `https://gitlab.com/api/v4/projects/${encodeURIComponent(config.project)}/${ep}/${iid}`;
+        const body = JSON.stringify({ title, state_event: 'close' });
+        const { request: httpsRequest } = await import('node:https');
+        const res = await new Promise((resolve, reject) => {
+            const u = new URL(url);
+            const req = httpsRequest({
+                hostname: u.hostname, port: u.port || 443,
+                path: u.pathname + u.search, method: 'PUT',
+                headers: {
+                    'PRIVATE-TOKEN': token, 'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(body),
+                },
+            }, (resp) => {
+                let data = '';
+                resp.on('data', (chunk) => data += chunk);
+                resp.on('end', () => resolve({
+                    status: resp.statusCode || 500,
+                    statusText: resp.statusMessage || 'Unknown',
+                    text: async () => data,
+                    json: async () => JSON.parse(data),
+                }));
+            });
+            req.on('error', reject);
+            req.write(body);
+            req.end();
+        });
+        if (res.status < 200 || res.status >= 300) {
+            const text = await res.text();
+            throw new Error(`GitLab API error ${res.status}: ${res.statusText} — ${text.slice(0, 200)}`);
+        }
+        return res.json();
+    }
+    if (config.provider === 'github' && config.owner && config.repo) {
+        const url = `https://api.github.com/repos/${config.owner}/${config.repo}/issues/${iid}`;
+        const body = JSON.stringify({ title, state: 'closed' });
+        const { request: httpsRequest } = await import('node:https');
+        const res = await new Promise((resolve, reject) => {
+            const u = new URL(url);
+            const req = httpsRequest({
+                hostname: u.hostname, port: u.port || 443,
+                path: u.pathname + u.search, method: 'PATCH',
+                headers: {
+                    'Authorization': `token ${token}`,
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(body),
+                    'User-Agent': 'm-cli',
+                    'Accept': 'application/vnd.github+json',
+                },
+            }, (resp) => {
+                let data = '';
+                resp.on('data', (chunk) => data += chunk);
+                resp.on('end', () => resolve({
+                    status: resp.statusCode || 500,
+                    statusText: resp.statusMessage || 'Unknown',
+                    text: async () => data,
+                    json: async () => JSON.parse(data),
+                }));
+            });
+            req.on('error', reject);
+            req.write(body);
+            req.end();
+        });
+        if (res.status < 200 || res.status >= 300) {
+            const text = await res.text();
+            throw new Error(`GitHub API error ${res.status}: ${res.statusText} — ${text.slice(0, 200)}`);
+        }
+        return res.json();
+    }
+    throw new Error('Configuración de repositorio incompleta');
+}
+export async function runReqClose(arg) {
+    const numbers = parseNumberList(arg);
+    if (numbers.length === 0) {
+        problem('Uso: req:close <N> [N2 N3 ...]');
+        return;
+    }
+    for (const number of numbers) {
+        info(`Cerrando #${number}...`);
+        await closeOne(number);
+    }
+    success(`✅ ${numbers.length} requerimiento(s) cerrado(s).`);
+}
+async function closeOne(number) {
+    const reqDir = await findReqDir();
+    const filePath = join(reqDir, `${number}.md`);
+    if (!existsSync(filePath)) {
+        problem(`No se encontró REQ/${number}.md`);
+        return;
+    }
+    const config = await getCurrentRepoConfig();
+    if (!config) {
+        problem('No se encontró configuración de repositorio. Asegúrate de tener git remote configurado.');
+        return;
+    }
+    const token = await readToken(config.provider);
+    if (!token) {
+        problem('No se encontró token. Configúralo en ~/.config/m/github-token o variable GITHUB_TOKEN');
+        return;
+    }
+    try {
+        // 1. Sync local → remote
+        const localContent = await readFile(filePath, 'utf-8');
+        const meta = parseReqFile(localContent, number);
+        const fullTitle = `${meta.type}-#${number}: ${meta.title}`;
+        await updateRemoteIssue(config, number, fullTitle, localContent, token);
+        info('✓ Sincronizado local → remoto.');
+        // 2. Close remote issue
+        await closeRemoteIssue(config, number, fullTitle, token);
+        info('✓ Issue cerrado en el repositorio remoto.');
+        // 3. Delete local REQ
+        const { unlink } = await import('node:fs/promises');
+        await unlink(filePath);
+        success(`✅ REQ/${number}.md cerrado y eliminado.`);
+    }
+    catch (err) {
+        problem(`Error al cerrar #${number}: ${err.message}`);
+    }
+}
+//# sourceMappingURL=req.js.map