viepilot 2.47.0 → 2.49.0

package/lib/intake/channels.cjs

@@ -0,0 +1,139 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const CHANNELS_REL = path.join('.viepilot', 'intake', 'channels.json');
+
+const REQUIRED_CHANNEL_FIELDS = ['id', 'type', 'name'];
+const REQUIRED_COLUMN_MAP_FIELDS = ['title', 'description'];
+const VALID_TYPES = ['csv', 'google_sheets', 'excel_m365'];
+
+const CHANNELS_SCAFFOLD = {
+  channels: [
+    {
+      id: 'csv-example',
+      type: 'csv',
+      name: 'Local CSV Export',
+      path: './reports/tickets.csv',
+      column_map: {
+        id: 'ticket_id',
+        title: 'summary',
+        description: 'details',
+        reporter: 'author',
+        date: 'created_at',
+        status: 'status',
+      },
+    },
+    {
+      id: 'gsheet-example',
+      type: 'google_sheets',
+      name: 'Google Sheet Tickets',
+      spreadsheet_id: 'REPLACE_WITH_SPREADSHEET_ID',
+      sheet_name: 'Sheet1',
+      column_map: {
+        id: 'A',
+        title: 'B',
+        description: 'C',
+        reporter: 'D',
+        date: 'E',
+        status: 'F',
+      },
+    },
+    {
+      id: 'm365-example',
+      type: 'excel_m365',
+      name: 'M365 Excel Tickets',
+      workbook_id: 'REPLACE_WITH_WORKBOOK_ID',
+      sheet_name: 'Tickets',
+      column_map: {
+        id: 'A',
+        title: 'B',
+        description: 'C',
+        reporter: 'D',
+        date: 'E',
+        status: 'F',
+      },
+    },
+  ],
+};
+
+function loadChannels(projectRoot) {
+  const channelsPath = path.join(projectRoot, CHANNELS_REL);
+  if (!fs.existsSync(channelsPath)) {
+    return { channels: [] };
+  }
+  try {
+    return JSON.parse(fs.readFileSync(channelsPath, 'utf8'));
+  } catch (e) {
+    throw new Error(`Failed to parse channels.json: ${e.message}`);
+  }
+}
+
+function validateChannel(channel) {
+  for (const field of REQUIRED_CHANNEL_FIELDS) {
+    if (!channel[field]) {
+      throw new Error(`Channel missing required field: "${field}"`);
+    }
+  }
+  if (!VALID_TYPES.includes(channel.type)) {
+    throw new Error(`Invalid channel type "${channel.type}". Must be one of: ${VALID_TYPES.join(', ')}`);
+  }
+  if (!channel.column_map) {
+    throw new Error(`Channel "${channel.id}" missing "column_map"`);
+  }
+  for (const field of REQUIRED_COLUMN_MAP_FIELDS) {
+    if (!channel.column_map[field]) {
+      throw new Error(`Channel "${channel.id}" column_map missing required field: "${field}"`);
+    }
+  }
+  if (channel.type === 'csv' && !channel.path) {
+    throw new Error(`CSV channel "${channel.id}" must have a "path" field`);
+  }
+  if (channel.type === 'google_sheets' && !channel.spreadsheet_id) {
+    throw new Error(`Google Sheets channel "${channel.id}" must have a "spreadsheet_id" field`);
+  }
+  if (channel.type === 'excel_m365' && !channel.workbook_id) {
+    throw new Error(`Excel/M365 channel "${channel.id}" must have a "workbook_id" field`);
+  }
+  return true;
+}
+
+function getChannelById(id, channels) {
+  return (channels || []).find((c) => c.id === id) || null;
+}
+
+function initIntakeDir(projectRoot) {
+  const intakeDir = path.join(projectRoot, '.viepilot', 'intake');
+  const channelsPath = path.join(intakeDir, 'channels.json');
+  const credentialsDir = path.join(projectRoot, '.viepilot', '.credentials');
+  const gitkeepPath = path.join(credentialsDir, '.gitkeep');
+  const gitignorePath = path.join(projectRoot, '.gitignore');
+
+  if (!fs.existsSync(intakeDir)) {
+    fs.mkdirSync(intakeDir, { recursive: true });
+  }
+
+  if (!fs.existsSync(channelsPath)) {
+    fs.writeFileSync(channelsPath, JSON.stringify(CHANNELS_SCAFFOLD, null, 2) + '\n', 'utf8');
+  }
+
+  if (!fs.existsSync(credentialsDir)) {
+    fs.mkdirSync(credentialsDir, { recursive: true });
+  }
+  if (!fs.existsSync(gitkeepPath)) {
+    fs.writeFileSync(gitkeepPath, '', 'utf8');
+  }
+
+  if (fs.existsSync(gitignorePath)) {
+    const existing = fs.readFileSync(gitignorePath, 'utf8');
+    const entry = '.viepilot/.credentials/';
+    if (!existing.includes(entry)) {
+      fs.appendFileSync(gitignorePath, `\n# ViePilot OAuth credentials (ENH-082)\n${entry}\n`, 'utf8');
+    }
+  }
+
+  return { intakeDir, channelsPath, credentialsDir };
+}
+
+module.exports = { loadChannels, validateChannel, getChannelById, initIntakeDir, CHANNELS_SCAFFOLD };

package/lib/intake/classifier.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+const BUG_KEYWORDS = [
+  'bug', 'error', 'fail', 'crash', 'broken', 'fix', 'exception', 'regression',
+  'wrong', 'incorrect', 'unexpected', 'null', 'undefined', '500', '404',
+  'performance', 'slow', 'timeout', 'hang', 'freeze', 'unresponsive',
+  // Vietnamese
+  'lỗi', 'sự cố', 'không hoạt động', 'hỏng', 'sai', 'vá lỗi', 'bị lỗi',
+  'chậm', 'treo', 'tắc', 'không phản hồi',
+];
+
+const ENH_KEYWORDS = [
+  'add', 'new', 'feature', 'improve', 'enhance', 'update', 'upgrade',
+  'support', 'request', 'implement', 'integrate', 'extend',
+  // Vietnamese
+  'thêm', 'nâng cấp', 'tính năng', 'cải tiến', 'tích hợp', 'mở rộng',
+  'yêu cầu', 'bổ sung', 'phát triển',
+];
+
+function classifyTicket(ticket) {
+  const text = `${ticket.title || ''} ${ticket.description || ''}`.toLowerCase();
+
+  for (const kw of BUG_KEYWORDS) {
+    if (text.includes(kw)) return 'BUG';
+  }
+  for (const kw of ENH_KEYWORDS) {
+    if (text.includes(kw)) return 'ENH';
+  }
+  return 'UNCLEAR';
+}
+
+module.exports = { classifyTicket };

package/lib/intake/report.cjs

@@ -0,0 +1,88 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+function truncate(str, max) {
+  if (!str) return '';
+  return str.length > max ? str.slice(0, max - 1) + '…' : str;
+}
+
+function generateTriageReport(channel, triageResult, projectRoot) {
+  const root = projectRoot || process.cwd();
+  const now = new Date();
+  const ts = now.toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const tsDisplay = now.toISOString();
+
+  const accepted = triageResult.accepted || [];
+  const declined = triageResult.declined || [];
+  const unclear  = triageResult.unclear  || [];
+  const total = accepted.length + declined.length + unclear.length;
+
+  const acceptedRows = accepted.map(({ ticket, request_id }) =>
+    `| ${ticket.id || ticket._source_row} | ${truncate(ticket.title, 50)} | ${ticket._classified || '?'} | ${request_id} |`
+  ).join('\n') || '| — | — | — | — |';
+
+  const declinedRows = declined.map(({ ticket, reason }) =>
+    `| ${ticket.id || ticket._source_row} | ${truncate(ticket.title, 50)} | ${truncate(reason, 60)} |`
+  ).join('\n') || '| — | — | — |';
+
+  const unclearRows = unclear.map(({ ticket }) =>
+    `| ${ticket.id || ticket._source_row} | ${truncate(ticket.title, 50)} |`
+  ).join('\n') || '| — | — |';
+
+  const pkgVersion = (() => {
+    try {
+      return require(path.join(root, 'package.json')).version;
+    } catch {
+      return 'unknown';
+    }
+  })();
+
+  const report = `# Triage Report — ${channel.name}
+
+**Session**: ${tsDisplay}
+**Channel**: ${channel.name} (${channel.type})
+**Total Tickets**: ${total}
+
+## Summary
+
+| Decision | Count |
+|----------|-------|
+| Accepted | ${accepted.length} |
+| Declined | ${declined.length} |
+| Unclear  | ${unclear.length} |
+
+## Accepted Tickets
+
+| Source ID | Title | Type | Request Created |
+|-----------|-------|------|-----------------|
+${acceptedRows}
+
+## Declined Tickets
+
+| Source ID | Title | Reason |
+|-----------|-------|--------|
+${declinedRows}
+
+## Unclear Tickets (not actioned)
+
+| Source ID | Title |
+|-----------|-------|
+${unclearRows}
+
+---
+*Generated by ViePilot vp-intake v${pkgVersion}*
+`;
+
+  const intakeDir = path.join(root, '.viepilot', 'intake');
+  if (!fs.existsSync(intakeDir)) {
+    fs.mkdirSync(intakeDir, { recursive: true });
+  }
+
+  const reportPath = path.join(intakeDir, `TRIAGE-${ts}.md`);
+  fs.writeFileSync(reportPath, report, 'utf8');
+  return reportPath;
+}
+
+module.exports = { generateTriageReport };

package/lib/intake/triage-ux.cjs

@@ -0,0 +1,151 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const DECLINE_REASONS = [
+  'Duplicate — already tracked',
+  'Out of scope for this project',
+  "Won't fix — low value",
+  'Deferred to future milestone',
+];
+
+function nextRequestNumber(type, projectRoot) {
+  const prefix = type === 'BUG' ? 'BUG-' : 'ENH-';
+  const reqDir = path.join(projectRoot, '.viepilot', 'requests');
+  if (!fs.existsSync(reqDir)) return 1;
+
+  const existing = fs.readdirSync(reqDir)
+    .filter((f) => f.startsWith(prefix) && f.endsWith('.md'))
+    .map((f) => parseInt(f.replace(prefix, '').replace('.md', ''), 10))
+    .filter((n) => !isNaN(n));
+
+  return existing.length ? Math.max(...existing) + 1 : 1;
+}
+
+function createRequestFile(ticket, type, channel, projectRoot) {
+  const n = nextRequestNumber(type, projectRoot);
+  const id = `${type}-${String(n).padStart(3, '0')}`;
+  const now = new Date().toISOString().split('T')[0];
+  const typeLabel = type === 'BUG' ? 'Bug' : 'Enhancement';
+
+  const content = `# ${typeLabel}: ${ticket.title}
+
+## Meta
+- **ID**: ${id}
+- **Type**: ${typeLabel}
+- **Status**: new
+- **Priority**: medium
+- **Created**: ${now}
+- **Reporter**: ${ticket.reporter || 'External source'}
+- **Source**: ${channel.name} — ticket #${ticket.id}
+- **Assignee**: AI
+
+## Summary
+${ticket.description || ticket.title}
+
+## Acceptance Criteria
+- [ ] (derived from description — fill in before planning)
+`;
+
+  const filePath = path.join(projectRoot, '.viepilot', 'requests', `${id}.md`);
+  fs.writeFileSync(filePath, content, 'utf8');
+  return { id, filePath };
+}
+
+function truncate(str, max) {
+  if (!str) return '';
+  return str.length > max ? str.slice(0, max - 1) + '…' : str;
+}
+
+async function runTriage(tickets, channel, projectRoot, askUserQuestionFn) {
+  const accepted = [];
+  const declined = [];
+  const unclear  = [];
+
+  const bugTickets     = tickets.filter((t) => t._classified === 'BUG');
+  const enhTickets     = tickets.filter((t) => t._classified === 'ENH');
+  const unclearTickets = tickets.filter((t) => t._classified === 'UNCLEAR');
+
+  console.log(`\n  BUG: ${bugTickets.length}  ENH: ${enhTickets.length}  UNCLEAR: ${unclearTickets.length}\n`);
+
+  const PAGE_SIZE = 4;
+
+  async function triagePage(pageTickets, labelPrefix) {
+    for (let offset = 0; offset < pageTickets.length; offset += PAGE_SIZE) {
+      const page = pageTickets.slice(offset, offset + PAGE_SIZE);
+      const pageNum = Math.floor(offset / PAGE_SIZE) + 1;
+      const totalPages = Math.ceil(pageTickets.length / PAGE_SIZE);
+
+      const question = totalPages > 1
+        ? `${labelPrefix} — Page ${pageNum}/${totalPages}: select tickets to ACCEPT`
+        : `${labelPrefix}: select tickets to ACCEPT`;
+
+      const options = page.map((t) => ({
+        label: `[${t._classified}] #${t.id || t._source_row} — ${truncate(t.title, 55)}`,
+        description: truncate(t.description, 100),
+      }));
+
+      const answer = await askUserQuestionFn(question, options, true);
+      const selectedLabels = Array.isArray(answer) ? answer : (answer ? [answer] : []);
+
+      for (const t of page) {
+        const label = `[${t._classified}] #${t.id || t._source_row} — ${truncate(t.title, 55)}`;
+        if (selectedLabels.includes(label)) {
+          accepted.push(t);
+        } else {
+          declined.push(t);
+        }
+      }
+    }
+  }
+
+  if (bugTickets.length > 0)  await triagePage(bugTickets,  'BUG tickets');
+  if (enhTickets.length > 0)  await triagePage(enhTickets,  'ENH tickets');
+
+  for (const t of unclearTickets) {
+    const answer = await askUserQuestionFn(
+      `UNCLEAR ticket #${t.id || t._source_row} — "${truncate(t.title, 60)}": how to handle?`,
+      [
+        { label: 'Accept as BUG', description: 'Create a BUG request' },
+        { label: 'Accept as ENH', description: 'Create an ENH request' },
+        { label: 'Decline', description: 'Skip this ticket' },
+      ],
+      false,
+    );
+    if (answer === 'Accept as BUG') {
+      t._classified = 'BUG';
+      accepted.push(t);
+    } else if (answer === 'Accept as ENH') {
+      t._classified = 'ENH';
+      accepted.push(t);
+    } else {
+      declined.push(t);
+    }
+  }
+
+  const acceptedWithIds = [];
+  for (const t of accepted) {
+    const { id } = createRequestFile(t, t._classified, channel, projectRoot);
+    acceptedWithIds.push({ ticket: t, request_id: id });
+    console.log(`  ✓ Created ${id} — ${t.title}`);
+  }
+
+  const declinedWithReasons = [];
+  for (const t of declined) {
+    const reason = await askUserQuestionFn(
+      `Reason for declining #${t.id || t._source_row} — "${truncate(t.title, 50)}"?`,
+      DECLINE_REASONS.map((r) => ({ label: r, description: '' })),
+      false,
+    );
+    declinedWithReasons.push({ ticket: t, reason: reason || 'No reason provided' });
+  }
+
+  return {
+    accepted: acceptedWithIds,
+    declined: declinedWithReasons,
+    unclear,
+  };
+}
+
+module.exports = { runTriage, nextRequestNumber };

package/lib/intake/writeback.cjs

@@ -0,0 +1,228 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const https = require('https');
+
+// ---------------------------------------------------------------------------
+// CSV write-back
+// ---------------------------------------------------------------------------
+
+function parseCsvLine(line, delimiter) {
+  const result = [];
+  let current = '';
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (ch === '"') {
+      if (inQuotes && line[i + 1] === '"') { current += '"'; i++; }
+      else inQuotes = !inQuotes;
+    } else if (ch === delimiter && !inQuotes) {
+      result.push(current); current = '';
+    } else {
+      current += ch;
+    }
+  }
+  result.push(current);
+  return result;
+}
+
+function csvCell(value) {
+  const s = String(value || '');
+  if (s.includes(',') || s.includes('"') || s.includes('\n')) {
+    return `"${s.replace(/"/g, '""')}"`;
+  }
+  return s;
+}
+
+function buildTicketDecisions(triageResult) {
+  const decisions = {};
+  for (const { ticket, request_id } of triageResult.accepted) {
+    decisions[ticket._source_row] = { vp_status: 'accepted', vp_comment: '', vp_request_id: request_id };
+  }
+  for (const { ticket, reason } of triageResult.declined) {
+    decisions[ticket._source_row] = { vp_status: 'declined', vp_comment: reason, vp_request_id: '' };
+  }
+  for (const { ticket } of (triageResult.unclear || [])) {
+    decisions[ticket._source_row] = { vp_status: 'unclear', vp_comment: '', vp_request_id: '' };
+  }
+  return decisions;
+}
+
+async function writebackCsv(channel, triageResult, projectRoot) {
+  const filePath = path.resolve(projectRoot || process.cwd(), channel.path);
+  if (!fs.existsSync(filePath)) {
+    return { success: false, error: `CSV file not found: ${filePath}` };
+  }
+
+  try {
+    const ext = path.extname(filePath).toLowerCase();
+    const delimiter = ext === '.tsv' ? '\t' : ',';
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split(/\r?\n/);
+    if (lines.length === 0) return { success: true };
+
+    let headers = parseCsvLine(lines[0], delimiter);
+    const VP_COLS = ['VP_Status', 'VP_Comment', 'VP_RequestID'];
+    const existingVpIdx = VP_COLS.map((col) => headers.indexOf(col));
+    const hasVpCols = existingVpIdx.every((i) => i >= 0);
+
+    if (!hasVpCols) {
+      headers = [...headers, ...VP_COLS];
+    }
+
+    const decisions = buildTicketDecisions(triageResult);
+    const outputLines = [headers.map(csvCell).join(delimiter)];
+
+    for (let i = 1; i < lines.length; i++) {
+      if (!lines[i].trim()) { outputLines.push(''); continue; }
+      const row = parseCsvLine(lines[i], delimiter);
+      const d = decisions[i];
+      if (d) {
+        while (row.length < headers.length) row.push('');
+        const statusIdx = headers.indexOf('VP_Status');
+        const commentIdx = headers.indexOf('VP_Comment');
+        const reqIdx = headers.indexOf('VP_RequestID');
+        if (statusIdx >= 0)  row[statusIdx] = d.vp_status;
+        if (commentIdx >= 0) row[commentIdx] = d.vp_comment;
+        if (reqIdx >= 0)     row[reqIdx] = d.vp_request_id;
+      }
+      outputLines.push(row.map(csvCell).join(delimiter));
+    }
+
+    fs.writeFileSync(filePath, outputLines.join('\n'), 'utf8');
+    return { success: true };
+  } catch (e) {
+    return { success: false, error: e.message };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Google Sheets write-back (batchUpdate)
+// ---------------------------------------------------------------------------
+
+function httpsRequest(method, url, body, headers) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const payload = body ? JSON.stringify(body) : '';
+    const req = https.request({
+      hostname: urlObj.hostname,
+      path: urlObj.pathname + urlObj.search,
+      method,
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload), ...headers },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => { try { resolve(JSON.parse(data)); } catch { resolve(data); } });
+    });
+    req.on('error', reject);
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
+function colLetterToIndex(letter) {
+  let index = 0;
+  for (const ch of letter.toUpperCase()) index = index * 26 + ch.charCodeAt(0) - 64;
+  return index - 1;
+}
+
+function indexToColLetter(idx) {
+  let letter = '';
+  idx++;
+  while (idx > 0) {
+    const rem = (idx - 1) % 26;
+    letter = String.fromCharCode(65 + rem) + letter;
+    idx = Math.floor((idx - 1) / 26);
+  }
+  return letter;
+}
+
+async function getGoogleAccessToken(projectRoot) {
+  const credPath = path.join(projectRoot, '.viepilot', '.credentials', 'google-service-account.json');
+  if (!fs.existsSync(credPath)) return null;
+  const keyJson = JSON.parse(fs.readFileSync(credPath, 'utf8'));
+  const now = Math.floor(Date.now() / 1000);
+  const header = Buffer.from(JSON.stringify({ alg: 'RS256', typ: 'JWT' })).toString('base64url');
+  const payload = Buffer.from(JSON.stringify({
+    iss: keyJson.client_email,
+    scope: 'https://www.googleapis.com/auth/spreadsheets',
+    aud: 'https://oauth2.googleapis.com/token',
+    exp: now + 3600, iat: now,
+  })).toString('base64url');
+  const crypto = require('crypto');
+  const sign = crypto.createSign('RSA-SHA256');
+  sign.update(`${header}.${payload}`);
+  const sig = sign.sign(keyJson.private_key, 'base64url');
+  const jwt = `${header}.${payload}.${sig}`;
+  const body = `grant_type=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Ajwt-bearer&assertion=${jwt}`;
+  const res = await httpsRequest('POST', 'https://oauth2.googleapis.com/token', null, {
+    'Content-Type': 'application/x-www-form-urlencoded',
+    'Content-Length': Buffer.byteLength(body),
+  });
+  return res.access_token || null;
+}
+
+async function writebackGoogleSheets(channel, triageResult, projectRoot) {
+  try {
+    const root = projectRoot || process.cwd();
+    const token = await getGoogleAccessToken(root);
+    if (!token) return { success: false, error: 'No Google credentials for write-back' };
+
+    const decisions = buildTicketDecisions(triageResult);
+    const allTickets = [
+      ...triageResult.accepted.map((a) => a.ticket),
+      ...triageResult.declined.map((d) => d.ticket),
+    ];
+    if (allTickets.length === 0) return { success: true };
+
+    const colMap = channel.column_map;
+    const lastCol = colLetterToIndex(Object.values(colMap).sort().pop() || 'F');
+    const vpStatusCol  = indexToColLetter(lastCol + 1);
+    const vpCommentCol = indexToColLetter(lastCol + 2);
+    const vpReqCol     = indexToColLetter(lastCol + 3);
+
+    const valueRanges = [];
+    for (const ticket of allTickets) {
+      const d = decisions[ticket._source_row];
+      if (!d) continue;
+      const rowNum = ticket._source_row + 1;
+      const sheetName = channel.sheet_name || 'Sheet1';
+      valueRanges.push({ range: `${sheetName}!${vpStatusCol}${rowNum}`,  values: [[d.vp_status]] });
+      valueRanges.push({ range: `${sheetName}!${vpCommentCol}${rowNum}`, values: [[d.vp_comment]] });
+      valueRanges.push({ range: `${sheetName}!${vpReqCol}${rowNum}`,     values: [[d.vp_request_id]] });
+    }
+
+    const url = `https://sheets.googleapis.com/v4/spreadsheets/${channel.spreadsheet_id}/values:batchUpdate`;
+    await httpsRequest('POST', url, { valueInputOption: 'RAW', data: valueRanges }, { Authorization: `Bearer ${token}` });
+    return { success: true };
+  } catch (e) {
+    return { success: false, error: e.message };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main writeback dispatcher
+// ---------------------------------------------------------------------------
+
+async function writeback(channel, triageResult, projectRoot) {
+  const root = projectRoot || process.cwd();
+  let result;
+
+  if (channel.type === 'csv') {
+    result = await writebackCsv(channel, triageResult, root);
+  } else if (channel.type === 'google_sheets') {
+    result = await writebackGoogleSheets(channel, triageResult, root);
+  } else if (channel.type === 'excel_m365') {
+    result = { success: false, error: 'Excel/M365 write-back requires Graph API — see task 123.4' };
+  } else {
+    result = { success: false, error: `Unknown channel type: ${channel.type}` };
+  }
+
+  if (!result.success) {
+    console.warn(`  ⚠ Write-back warning: ${result.error} — triage report is the source of truth`);
+  }
+  return result;
+}
+
+module.exports = { writeback };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viepilot",
-  "version": "2.47.0",
+  "version": "2.49.0",
   "description": "**Autonomous Vibe Coding Framework / Bộ khung phát triển tự động có kiểm soát**",
   "main": "index.js",
   "bin": {
@@ -74,7 +74,8 @@
   },
   "dependencies": {
     "docx": "^9.0.0",
-    "pptxgenjs": "^3.12.0"
+    "pptxgenjs": "^3.12.0",
+    "xlsx": "^0.18.5"
   },
   "optionalDependencies": {
     "@googleapis/slides": "^1.0.0"