@mrselva/attendance 0.0.0-stage → 1.1.0

package/README.md

@@ -1,3 +1,119 @@
-# Temporary Holding Version
+# @mrselva/attendance
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm version](https://img.shields.io/npm/v/@mrselva/attendance.svg)](https://www.npmjs.com/package/@mrselva/attendance)
+[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](LICENSE)
+[![Node.js Version](https://img.shields.io/badge/node-%3E%3D16.0.0-brightgreen.svg)](https://nodejs.org)
+
+> An automated CLI converter that extracts vertical-wise attendance data from KG-KITE / SoI multi-sheet attendance spreadsheets, generates DigiCampus-compliant upload workbooks, and bundles them into clean ZIP archives.
+
+Run instantly with **`npx`** — no cloning or installation required!
+
+---
+
+## ⚡ Quick Start
+
+Open your terminal in any folder containing your attendance spreadsheet (or an `input/` folder):
+
+```bash
+npx @mrselva/attendance
+```
+
+Or install globally:
+
+```bash
+npm install -g @mrselva/attendance
+attendance
+```
+
+---
+
+## ✨ Features
+
+- **Zero Configuration & Auto-Import**: If no file is in `./input/`, an OS file picker dialog pops up so you can simply click your spreadsheet (from Downloads or anywhere), and it automatically imports it into `./input/`! Drag & drop file paths into the terminal is also supported.
+- **Interactive CLI Wizard**: Clean, color-coded terminal prompts to pick verticals and date ranges.
+- **Comprehensive Vertical Support**: Detects lab vertical sheets:
+  - `AD`: AI & Data Science Lab
+  - `BW`: Blockchain and Web3.0 Lab
+  - `CD`: Cloud and DevOps Lab
+  - `CS`: Cyber Security Lab
+  - `DMA`: Data & Mobile Analytics Lab
+  - `EI`: Embedded & IoT Lab
+  - `FW`: Full Stack Web Lab
+  - `SOAL`: School of AI Learning
+  - `SOP`: School of Programming
+- **Smart Date Filtering**:
+  - Export **All recorded dates** (creates one upload file per instructional date)
+  - Export a **Single date** (e.g. `2024-09-15`)
+  - Export a **Date range** (from `YYYY-MM-DD` to `YYYY-MM-DD`)
+  - Export the **Latest date only**
+- **DigiCampus Compatibility**: Creates individual files with a `Students` sheet formatted with:
+  - `Email Id`
+  - `Registration Id`
+  - `Attendance *` (`PRESENT` or `ABSENT`)
+- **Status Normalization**: Accurately normalizes marks (`P`, `1`, `OD`, `ELITE` → `PRESENT`; `A`, `0`, unrecorded → `ABSENT`).
+- **Automatic ZIP Packaging**: Compresses generated files directly into `./output/<Vertical>_Attendance.zip`.
+
+---
+
+## 🚀 CLI Usage & Flags
+
+You can run the interactive wizard or pass non-interactive CLI flags for automation:
+
+```bash
+# Interactive mode
+npx @mrselva/attendance
+
+# Export ALL dates for a specific vertical
+npx @mrselva/attendance -v BW -a
+
+# Export a single date
+npx @mrselva/attendance -v CD -d 2024-09-12
+
+# Export the latest date recorded
+npx @mrselva/attendance -v AD --latest
+
+# Process ALL verticals at once
+npx @mrselva/attendance -v ALL -a
+
+# Specify a custom input spreadsheet file
+npx @mrselva/attendance -f "2024-28_SoI_Attendance_Sheet.xlsx" -v FW -a
+```
+
+### Options Reference
+
+| Flag | Long Flag | Description |
+| :--- | :--- | :--- |
+| `-v <code\|ALL>` | `--vertical <code\|ALL>` | Vertical code (e.g. `AD`, `BW`, `CD`, `CS`, `DMA`, `EI`, `FW`, or `ALL`) |
+| `-a` | `--all` | Export all recorded instructional dates |
+| `-d <date>` | `--date <YYYY-MM-DD>` | Export a specific date |
+| | `--latest` | Export the latest instructional date |
+| `-f <file>` | `--file <path>` | Specify input Excel file path or filename |
+| `-h` | `--help` | Display usage and help message |
+
+---
+
+## 📁 Directory Structure
+
+```text
+your-folder/
+├── input/                             # (Optional) Place source spreadsheets here
+│   └── 2024-28_SoI_Attendance.xlsx
+└── output/                            # Automatically generated output
+    ├── BW_Attendance.zip
+    └── CD_Attendance.zip
+```
+
+> **Note:** If an `input/` folder is not found, the CLI will look for Excel files directly in your current working directory.
+
+---
+
+## 🛠 Requirements
+
+- **Node.js**: `v16.0.0` or higher
+- **npm**: `v7.0.0` or higher (included with Node.js)
+
+---
+
+## 📄 License
+
+[ISC](LICENSE) &copy; [mrselva-eth](https://github.com/mrselva-eth)

package/index.js

@@ -0,0 +1,824 @@
+#!/usr/bin/env node
+/**
+ * Attendance to DigiCampus Converter
+ * Single-file Node.js CLI script
+ * 
+ * Features:
+ * - Scans ./input for attendance spreadsheets (.xlsx / .xls)
+ * - Interactively prompts for vertical selection (AD, BW, CD, CS, DMA, EI, FW, etc.)
+ * - Allows exporting all recorded dates, specific date, range, or latest date
+ * - Generates individual DigiCampus-compliant Excel files ('Students' sheet with Email Id, Registration Id, Attendance *)
+ * - Automatically packages all generated files into a ZIP archive in ./output
+ * - Works both interactively (in terminal) and with optional CLI flags (--vertical, --all, etc.)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { execFileSync } = require('child_process');
+const xlsx = require('xlsx');
+const AdmZip = require('adm-zip');
+
+// Paths (relative to user current working directory where npx is executed)
+const INPUT_DIR = path.resolve(process.cwd(), 'input');
+const OUTPUT_DIR = path.resolve(process.cwd(), 'output');
+
+// Known vertical full names mapping
+const VERTICAL_NAMES = {
+  'AD': 'AI & Data Science Lab',
+  'BW': 'Blockchain and Web3.0 Lab',
+  'CD': 'Cloud and DevOps Lab',
+  'CS': 'Cyber Security Lab',
+  'DMA': 'Data & Mobile Analytics Lab',
+  'EI': 'Embedded & IoT Lab',
+  'FW': 'Full Stack Web Lab',
+  'SOAL': 'School of AI Learning',
+  'SOP': 'School of Programming'
+};
+
+// ANSI color helpers
+const colors = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  cyan: '\x1b[36m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  magenta: '\x1b[35m',
+  blue: '\x1b[34m'
+};
+
+function logHeader(text) {
+  console.log(`\n${colors.bold}${colors.cyan}=== ${text} ===${colors.reset}`);
+}
+
+function logSuccess(text) {
+  console.log(`${colors.green}✓ ${text}${colors.reset}`);
+}
+
+function logInfo(text) {
+  console.log(`${colors.blue}ℹ ${text}${colors.reset}`);
+}
+
+function logWarn(text) {
+  console.log(`${colors.yellow}⚠ ${text}${colors.reset}`);
+}
+
+function logError(text) {
+  console.log(`${colors.red}✖ ${text}${colors.reset}`);
+}
+
+// Ensure required directories exist
+function ensureDirs() {
+  if (!fs.existsSync(INPUT_DIR)) {
+    fs.mkdirSync(INPUT_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(OUTPUT_DIR)) {
+    fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+  }
+}
+
+// Find excel files in input folder or current working directory
+function findInputFiles() {
+  ensureDirs();
+  const results = [];
+  const seenPaths = new Set();
+
+  const isExcel = f => {
+    const ext = path.extname(f).toLowerCase();
+    return (ext === '.xlsx' || ext === '.xls') && !path.basename(f).startsWith('~$');
+  };
+
+  // 1. Check ./input directory first
+  if (fs.existsSync(INPUT_DIR)) {
+    try {
+      const files = fs.readdirSync(INPUT_DIR).filter(isExcel);
+      for (const f of files) {
+        const fullPath = path.join(INPUT_DIR, f);
+        if (!seenPaths.has(fullPath)) {
+          seenPaths.add(fullPath);
+          results.push({ name: f, fullPath, relativePath: path.join('input', f) });
+        }
+      }
+    } catch (e) {}
+  }
+
+  // 2. Also check current working directory
+  try {
+    const cwdFiles = fs.readdirSync(process.cwd()).filter(isExcel);
+    for (const f of cwdFiles) {
+      const fullPath = path.join(process.cwd(), f);
+      if (!seenPaths.has(fullPath)) {
+        seenPaths.add(fullPath);
+        results.push({ name: f, fullPath, relativePath: f });
+      }
+    }
+  } catch (e) {}
+
+  return results;
+}
+
+// Format date into YYYY-MM-DD
+function formatDate(val, cellRaw) {
+  if (val === null || val === undefined) return null;
+
+  // If number (Excel date code)
+  if (typeof val === 'number') {
+    try {
+      const parsed = xlsx.SSF.parse_date_code(val);
+      if (parsed && parsed.y && parsed.m && parsed.d) {
+        const y = String(parsed.y).padStart(4, '0');
+        const m = String(parsed.m).padStart(2, '0');
+        const d = String(parsed.d).padStart(2, '0');
+        return `${y}-${m}-${d}`;
+      }
+    } catch (e) {}
+  }
+
+  // If Date object
+  if (val instanceof Date) {
+    const y = val.getUTCFullYear();
+    const m = String(val.getUTCMonth() + 1).padStart(2, '0');
+    const d = String(val.getUTCDate()).padStart(2, '0');
+    return `${y}-${m}-${d}`;
+  }
+
+  // If string, inspect raw formatted text
+  const str = String(val).trim();
+  const isoMatch = str.match(/^(\d{4})-(\d{1,2})-(\d{1,2})/);
+  if (isoMatch) {
+    return `${isoMatch[1]}-${isoMatch[2].padStart(2, '0')}-${isoMatch[3].padStart(2, '0')}`;
+  }
+
+  if (cellRaw && cellRaw.w) {
+    const dt = new Date(cellRaw.w);
+    if (!isNaN(dt.getTime())) {
+      const y = dt.getFullYear();
+      const m = String(dt.getMonth() + 1).padStart(2, '0');
+      const d = String(dt.getDate()).padStart(2, '0');
+      return `${y}-${m}-${d}`;
+    }
+  }
+
+  const dt = new Date(str);
+  if (!isNaN(dt.getTime())) {
+    const y = dt.getFullYear();
+    const m = String(dt.getMonth() + 1).padStart(2, '0');
+    const d = String(dt.getDate()).padStart(2, '0');
+    return `${y}-${m}-${d}`;
+  }
+
+  return null;
+}
+
+// Normalize attendance status:
+// Returns 'PRESENT', 'ABSENT', or null (if empty, holiday, remark, etc.)
+function normalizeStatus(val) {
+  if (val === null || val === undefined) return null;
+  const s = String(val).trim().toUpperCase();
+  if (s === '') return null;
+
+  if (s === 'PRESENT' || s === 'P' || s === '1' || s === 'OD' || s === 'ELITE') {
+    return 'PRESENT';
+  }
+  if (s === 'ABSENT' || s === 'A' || s === '0') {
+    return 'ABSENT';
+  }
+
+  // Non-attendance values (holidays, test codes, remarks)
+  return null;
+}
+
+// Parse a vertical sheet to extract students and date columns
+function parseVerticalSheet(ws, sheetName) {
+  const rows = xlsx.utils.sheet_to_json(ws, { header: 1, raw: true, defval: null });
+  if (!rows || rows.length < 2) return null;
+
+  const headerRow = rows[0];
+
+  let regColIdx = -1;
+  let nameColIdx = -1;
+  let emailColIdx = -1;
+  let rollColIdx = -1;
+  let isKiteEmail = false;
+  const dateColumns = [];
+
+  // Analyze header row
+  for (let c = 0; c < headerRow.length; c++) {
+    const hVal = headerRow[c];
+    if (hVal === null || hVal === undefined) continue;
+
+    const hStr = String(hVal).trim().toLowerCase();
+
+    if (hStr.includes('register') || hStr.includes('reg no') || hStr.includes('reg.') || hStr.includes('registration id')) {
+      regColIdx = c;
+    } else if (hStr.includes('student name') || hStr === 'name') {
+      nameColIdx = c;
+    } else if (hStr.includes('kite email')) {
+      emailColIdx = c;
+      isKiteEmail = true;
+    } else if (!isKiteEmail && (hStr.includes('email id') || hStr.includes('email'))) {
+      if (!hStr.includes('soi')) {
+        emailColIdx = c;
+      }
+    } else if (hStr.includes('roll number') || hStr.includes('roll no')) {
+      rollColIdx = c;
+    } else {
+      const cellAddress = xlsx.utils.encode_cell({ r: 0, c: c });
+      const cellRaw = ws[cellAddress];
+      const dateStr = formatDate(hVal, cellRaw);
+      if (dateStr) {
+        const display = cellRaw && cellRaw.w ? cellRaw.w : dateStr;
+        dateColumns.push({ colIdx: c, dateStr, displayDate: display });
+      }
+    }
+  }
+
+  if (regColIdx === -1 || dateColumns.length === 0) {
+    return null; // Not a vertical attendance sheet
+  }
+
+  // Parse student records
+  const students = [];
+  for (let r = 1; r < rows.length; r++) {
+    const row = rows[r];
+    if (!row) continue;
+
+    const sno = row[0];
+    const name = nameColIdx !== -1 ? String(row[nameColIdx] || '').trim() : '';
+    const regNo = regColIdx !== -1 ? String(row[regColIdx] || '').trim() : '';
+    const email = emailColIdx !== -1 ? String(row[emailColIdx] || '').trim() : '';
+    const rollNo = rollColIdx !== -1 ? String(row[rollColIdx] || '').trim() : '';
+
+    // Ignore summary/totals rows at bottom
+    const isSummary = /no\s*\.?\s*of/i.test(name) || 
+                      /no\s*\.?\s*of/i.test(regNo) || 
+                      /total/i.test(name) || 
+                      /total/i.test(regNo) ||
+                      /present/i.test(regNo) ||
+                      /absent/i.test(regNo);
+    if (isSummary) continue;
+
+    if (!name || name.length < 2) continue;
+    if (sno !== null && sno !== undefined && isNaN(Number(sno))) continue;
+    if (!regNo && !rollNo) continue;
+
+    students.push({
+      rowIdx: r,
+      sno: sno,
+      name: name,
+      regNo: regNo,
+      rollNo: rollNo,
+      email: email || (rollNo ? `${rollNo.toLowerCase()}@kgkite.ac.in` : '')
+    });
+  }
+
+  if (students.length === 0) return null;
+
+  // Filter dates to only those that have actual student attendance recorded
+  const instructionalDates = [];
+  for (const dc of dateColumns) {
+    let presentCount = 0;
+    let absentCount = 0;
+
+    for (const student of students) {
+      const cellVal = rows[student.rowIdx] ? rows[student.rowIdx][dc.colIdx] : null;
+      const norm = normalizeStatus(cellVal);
+      if (norm === 'PRESENT') {
+        presentCount++;
+      } else if (norm === 'ABSENT') {
+        absentCount++;
+      }
+    }
+
+    // Only if at least one student was marked PRESENT or ABSENT
+    if (presentCount + absentCount > 0) {
+      instructionalDates.push({
+        ...dc,
+        presentCount,
+        absentCount,
+        totalStudents: students.length
+      });
+    }
+  }
+
+  // Sort dates chronologically
+  instructionalDates.sort((a, b) => a.dateStr.localeCompare(b.dateStr));
+
+  return {
+    sheetName,
+    verticalName: VERTICAL_NAMES[sheetName] || sheetName,
+    students,
+    dates: instructionalDates,
+    allDateColumns: dateColumns
+  };
+}
+
+// Generate DigiCampus Excel workbook for a single date
+function generateDigiCampusWorkbook(verticalData, dateItem, rows) {
+  const wb = xlsx.utils.book_new();
+
+  // DigiCampus Template Header
+  const wsData = [
+    ['Email Id', 'Registration Id', 'Attendance *']
+  ];
+
+  for (const student of verticalData.students) {
+    const rawVal = rows[student.rowIdx] ? rows[student.rowIdx][dateItem.colIdx] : null;
+    let status = normalizeStatus(rawVal);
+    // On an instructional day, any unrecorded or blank student is marked ABSENT
+    if (!status) {
+      status = 'ABSENT';
+    }
+
+    wsData.push([
+      student.email,
+      student.regNo,
+      status
+    ]);
+  }
+
+  const ws = xlsx.utils.aoa_to_sheet(wsData);
+
+  // Set column widths for clean readability
+  ws['!cols'] = [
+    { wch: 35 }, // Email Id
+    { wch: 20 }, // Registration Id
+    { wch: 15 }  // Attendance *
+  ];
+
+  xlsx.utils.book_append_sheet(wb, ws, 'Students');
+  return wb;
+}
+
+// Parse Command Line Arguments (allows both CLI flags and interactive mode)
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const flags = {
+    vertical: null,
+    all: false,
+    date: null,
+    startDate: null,
+    endDate: null,
+    latest: false,
+    file: null,
+    help: false
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '-h' || a === '--help') {
+      flags.help = true;
+    } else if (a === '-v' || a === '--vertical') {
+      flags.vertical = args[++i];
+    } else if (a === '-a' || a === '--all' || a === '--all-dates') {
+      flags.all = true;
+    } else if (a === '-d' || a === '--date') {
+      flags.date = args[++i];
+    } else if (a === '--latest') {
+      flags.latest = true;
+    } else if (a === '-f' || a === '--file') {
+      flags.file = args[++i];
+    } else if (!a.startsWith('-') && !flags.vertical) {
+      flags.vertical = a;
+    }
+  }
+
+  return flags;
+}
+
+// Clean user input file path (strip quotes and shell prefixes)
+function cleanPath(input) {
+  if (!input) return '';
+  let str = input.trim();
+  if (str.startsWith('&')) {
+    str = str.slice(1).trim();
+  }
+  if ((str.startsWith('"') && str.endsWith('"')) || (str.startsWith("'") && str.endsWith("'"))) {
+    str = str.slice(1, -1).trim();
+  }
+  return str;
+}
+
+// Open native OS file picker dialog
+function openFileDialog() {
+  const platform = process.platform;
+  try {
+    if (platform === 'win32') {
+      const psScript = `
+Add-Type -AssemblyName System.Windows.Forms
+$dlg = New-Object System.Windows.Forms.OpenFileDialog
+$dlg.Filter = 'Excel Files (*.xlsx;*.xls)|*.xlsx;*.xls|All Files (*.*)|*.*'
+$dlg.Title = 'Select Attendance Spreadsheet'
+$dlg.RestoreDirectory = $true
+$result = $dlg.ShowDialog()
+if ($result -eq [System.Windows.Forms.DialogResult]::OK) {
+    Write-Output $dlg.FileName
+}
+`;
+      const output = execFileSync('powershell.exe', ['-NoProfile', '-STA', '-Command', psScript], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: 180000
+      });
+      return output ? output.trim() : null;
+    } else if (platform === 'darwin') {
+      const appleScript = 'POSIX path of (choose file with prompt "Select Attendance Spreadsheet" of type {"xlsx", "xls"})';
+      const output = execFileSync('osascript', ['-e', appleScript], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore']
+      });
+      return output ? output.trim() : null;
+    } else {
+      const output = execFileSync('zenity', ['--file-selection', '--file-filter=Excel files | *.xlsx *.xls', '--title=Select Attendance Spreadsheet'], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore']
+      });
+      return output ? output.trim() : null;
+    }
+  } catch (e) {
+    return null;
+  }
+}
+
+// Copy / import a selected spreadsheet into ./input/
+function importFileToInput(srcPath) {
+  ensureDirs();
+  const fileName = path.basename(srcPath);
+  const destPath = path.join(INPUT_DIR, fileName);
+
+  if (path.resolve(srcPath) !== path.resolve(destPath)) {
+    try {
+      fs.copyFileSync(srcPath, destPath);
+      logSuccess(`Imported "${fileName}" into ./input/ folder!`);
+      return {
+        name: fileName,
+        fullPath: destPath,
+        relativePath: path.join('input', fileName)
+      };
+    } catch (err) {
+      logWarn(`Could not copy into ./input/ (${err.message}). Reading from original location.`);
+      return {
+        name: fileName,
+        fullPath: srcPath,
+        relativePath: srcPath
+      };
+    }
+  }
+
+  return {
+    name: fileName,
+    fullPath: destPath,
+    relativePath: path.relative(process.cwd(), destPath) || path.join('input', fileName)
+  };
+}
+
+// Interactive prompt for file selection when needed
+async function promptForFile(lines) {
+  logHeader('Select Attendance Spreadsheet');
+  console.log('No attendance spreadsheet selected yet.');
+  console.log('Please choose how you want to select your Excel file (.xlsx / .xls):\n');
+  console.log(`  [${colors.bold}1${colors.reset}] ${colors.green}Browse file${colors.reset} (Opens file picker window to click your file) [Default]`);
+  console.log(`  [${colors.bold}2${colors.reset}] ${colors.cyan}Enter or drag & drop file path here${colors.reset}`);
+
+  while (true) {
+    const choice = (await askQuestion(lines, `\nChoose option [1 or 2] (default: 1): `)).trim();
+
+    if (choice === '2') {
+      const manual = await askQuestion(lines, 'Enter or drag & drop file path: ');
+      const cleaned = cleanPath(manual);
+      if (cleaned && fs.existsSync(cleaned) && fs.statSync(cleaned).isFile()) {
+        const ext = path.extname(cleaned).toLowerCase();
+        if (ext === '.xlsx' || ext === '.xls') {
+          return cleaned;
+        } else {
+          logWarn(`"${cleaned}" is not an Excel spreadsheet (.xlsx / .xls).`);
+        }
+      } else {
+        logError(`File not found at: "${cleaned}". Please check the path and try again.`);
+      }
+    } else {
+      console.log(`${colors.dim}Opening file picker dialog... Please select your file in the window.${colors.reset}`);
+      const picked = openFileDialog();
+      if (picked && fs.existsSync(picked) && fs.statSync(picked).isFile()) {
+        return picked;
+      }
+      logWarn('No file was selected in the dialog.');
+      console.log(`You can try browsing again [1], or enter/drag & drop the file path directly [2]:`);
+    }
+  }
+}
+
+// Interactive prompt helper
+async function askQuestion(lineIterator, promptText) {
+  process.stdout.write(promptText);
+  const next = await lineIterator.next();
+  if (next.done) return '';
+  return (next.value || '').trim();
+}
+
+// Main execution function
+async function main() {
+  const flags = parseArgs();
+
+  if (flags.help) {
+    console.log(`
+Usage: npx @mrselva/attendance [options] [vertical]
+       or: attendance [options] [vertical]
+       or: node index.js [options] [vertical]
+
+Options:
+  -v, --vertical <code/name>  Vertical code (e.g., AD, BW, CD, CS, DMA, EI, FW, ALL)
+  -a, --all                   Export all instructional dates automatically
+  -d, --date <YYYY-MM-DD>     Export a single specific date
+  --latest                    Export the latest instructional date
+  -f, --file <filename/path>  Specify input Excel file name or path
+  -h, --help                  Show this help message
+
+Running without options launches the interactive CLI wizard.
+`);
+    process.exit(0);
+  }
+
+  console.log(`\n${colors.bold}${colors.magenta}╔═════════════════════════════════════════════════════════════════════╗`);
+  console.log(`║          KG-KITE / SoI Attendance -> DigiCampus Exporter            ║`);
+  console.log(`╚═════════════════════════════════════════════════════════════════════╝${colors.reset}`);
+
+  ensureDirs();
+
+  let selectedFileObj = null;
+
+  // Create readline interface for interactive questions
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: process.stdin.isTTY
+  });
+  const lines = rl[Symbol.asyncIterator]();
+
+  if (flags.file) {
+    const directPath = path.resolve(process.cwd(), flags.file);
+    const inInputPath = path.join(INPUT_DIR, flags.file);
+    let resolvedSrc = null;
+    if (fs.existsSync(directPath) && fs.statSync(directPath).isFile()) {
+      resolvedSrc = directPath;
+    } else if (fs.existsSync(inInputPath) && fs.statSync(inInputPath).isFile()) {
+      resolvedSrc = inInputPath;
+    } else {
+      logError(`Specified file "${flags.file}" was not found.`);
+      rl.close();
+      process.exit(1);
+    }
+    selectedFileObj = importFileToInput(resolvedSrc);
+  } else {
+    const inputFiles = findInputFiles();
+
+    if (inputFiles.length === 0) {
+      // Auto prompt to browse or drag & drop when input/ is empty
+      const chosen = await promptForFile(lines);
+      selectedFileObj = importFileToInput(chosen);
+    } else if (inputFiles.length === 1) {
+      logInfo(`Found existing attendance spreadsheet: ${colors.bold}${inputFiles[0].relativePath}${colors.reset}`);
+      console.log(`  [${colors.bold}1${colors.reset}] Use this spreadsheet [Default]`);
+      console.log(`  [${colors.bold}2${colors.reset}] Choose/import a different file`);
+      const pick = (await askQuestion(lines, `\nSelect option [1 or 2] (default: 1): `)).trim();
+      if (pick === '2') {
+        const chosen = await promptForFile(lines);
+        selectedFileObj = importFileToInput(chosen);
+      } else {
+        selectedFileObj = inputFiles[0];
+      }
+    } else {
+      logHeader('Select Input Attendance File');
+      inputFiles.forEach((fileObj, idx) => {
+        console.log(`  [${colors.bold}${idx + 1}${colors.reset}] ${fileObj.relativePath}`);
+      });
+      console.log(`  [${colors.bold}N${colors.reset}] ${colors.cyan}Import a new spreadsheet${colors.reset} (Browse or drag & drop)`);
+      const ans = (await askQuestion(lines, `\nSelect file [1-${inputFiles.length}] or N (default: 1): `)).trim();
+      if (ans.toUpperCase() === 'N') {
+        const chosen = await promptForFile(lines);
+        selectedFileObj = importFileToInput(chosen);
+      } else {
+        const num = parseInt(ans, 10);
+        if (!isNaN(num) && num >= 1 && num <= inputFiles.length) {
+          selectedFileObj = inputFiles[num - 1];
+        } else {
+          selectedFileObj = inputFiles[0];
+        }
+      }
+    }
+  }
+
+  const inputFilePath = selectedFileObj.fullPath;
+  logInfo(`Reading attendance workbook: ${colors.bold}${selectedFileObj.relativePath || selectedFileObj.name}${colors.reset}`);
+  
+  let workbook;
+  try {
+    workbook = xlsx.readFile(inputFilePath, { cellDates: false });
+  } catch (err) {
+    logError(`Failed to read Excel file: ${err.message}`);
+    rl.close();
+    process.exit(1);
+  }
+
+  // Discover all vertical sheets
+  const verticalSheets = [];
+  const excludedSheets = ['pivot table', 'summary', 'template', 'students data'];
+
+  for (const sheetName of workbook.SheetNames) {
+    if (excludedSheets.some(ex => sheetName.toLowerCase().includes(ex))) {
+      continue;
+    }
+    const ws = workbook.Sheets[sheetName];
+    const parsed = parseVerticalSheet(ws, sheetName);
+    if (parsed) {
+      verticalSheets.push(parsed);
+    }
+  }
+
+  if (verticalSheets.length === 0) {
+    logError('No valid vertical attendance sheets with students and date columns were found.');
+    rl.close();
+    process.exit(1);
+  }
+
+  // Vertical Selection
+  let chosenVertical = null;
+  let processAll = false;
+
+  if (flags.vertical) {
+    const vArg = flags.vertical.toUpperCase().trim();
+    if (vArg === 'ALL' || vArg === 'A') {
+      processAll = true;
+    } else {
+      chosenVertical = verticalSheets.find(v => 
+        v.sheetName.toUpperCase() === vArg ||
+        v.verticalName.toUpperCase().includes(vArg)
+      );
+      if (!chosenVertical) {
+        logWarn(`Vertical "${flags.vertical}" not found. Falling back to interactive selection.`);
+      }
+    }
+  }
+
+  // Interactive selection if not resolved from flags
+  if (!chosenVertical && !processAll) {
+    logHeader('Select Vertical');
+    console.log('Available verticals found in the spreadsheet:\n');
+    
+    verticalSheets.forEach((v, idx) => {
+      const code = colors.bold + v.sheetName.padEnd(5) + colors.reset;
+      const name = (v.verticalName !== v.sheetName ? `(${v.verticalName})` : '').padEnd(35);
+      const countInfo = `${colors.dim}${v.students.length} students, ${v.dates.length} dates recorded${colors.reset}`;
+      console.log(`  [${colors.bold}${idx + 1}${colors.reset}] ${code} ${name} ${countInfo}`);
+    });
+    console.log(`  [${colors.bold}A${colors.reset}] ${colors.bold}ALL  ${colors.reset} (Process ALL verticals at once)`);
+
+    while (!chosenVertical && !processAll) {
+      const ans = (await askQuestion(lines, `\nEnter vertical number or code [1-${verticalSheets.length} / Code]: `)).trim();
+      
+      if (ans.toUpperCase() === 'A' || ans.toUpperCase() === 'ALL') {
+        processAll = true;
+        break;
+      }
+
+      const num = parseInt(ans, 10);
+      if (!isNaN(num) && num >= 1 && num <= verticalSheets.length) {
+        chosenVertical = verticalSheets[num - 1];
+        break;
+      }
+
+      const matched = verticalSheets.find(v => 
+        v.sheetName.toLowerCase() === ans.toLowerCase() || 
+        v.verticalName.toLowerCase().includes(ans.toLowerCase())
+      );
+      if (matched) {
+        chosenVertical = matched;
+        break;
+      }
+
+      logWarn(`Invalid selection "${ans}". Please enter 1-${verticalSheets.length} or the vertical code.`);
+    }
+  }
+
+  const targets = processAll ? verticalSheets : [chosenVertical];
+
+  // Date selection logic
+  let dateFilterMode = 'ALL';
+  let singleDateVal = flags.date || null;
+  let dateRangeVal = null;
+
+  if (flags.all) {
+    dateFilterMode = 'ALL';
+  } else if (flags.latest) {
+    dateFilterMode = 'LATEST';
+  } else if (flags.date) {
+    dateFilterMode = 'SINGLE';
+  } else if (!processAll) {
+    const totalDates = chosenVertical.dates.length;
+    const firstDate = totalDates > 0 ? chosenVertical.dates[0].dateStr : 'N/A';
+    const lastDate = totalDates > 0 ? chosenVertical.dates[totalDates - 1].dateStr : 'N/A';
+
+    logHeader(`Date Selection for Vertical: ${chosenVertical.sheetName}`);
+    console.log(`Found ${colors.bold}${totalDates}${colors.reset} instructional dates (${firstDate} to ${lastDate}).\n`);
+    console.log(`  [${colors.bold}1${colors.reset}] Export ${colors.green}ALL ${totalDates} dates${colors.reset} (Recommended - generates upload files for each date)`);
+    console.log(`  [${colors.bold}2${colors.reset}] Export a ${colors.cyan}single specific date${colors.reset} (e.g., ${lastDate})`);
+    console.log(`  [${colors.bold}3${colors.reset}] Export a ${colors.yellow}date range${colors.reset} (from YYYY-MM-DD to YYYY-MM-DD)`);
+    console.log(`  [${colors.bold}4${colors.reset}] Export the ${colors.magenta}latest date only${colors.reset} (${lastDate})`);
+
+    const dateChoice = (await askQuestion(lines, `\nChoose export option [1-4] (default: 1): `)).trim();
+
+    if (dateChoice === '2') {
+      dateFilterMode = 'SINGLE';
+      const dAns = (await askQuestion(lines, `Enter date (YYYY-MM-DD) [default: ${lastDate}]: `)).trim();
+      singleDateVal = dAns || lastDate;
+    } else if (dateChoice === '3') {
+      dateFilterMode = 'RANGE';
+      const startAns = (await askQuestion(lines, `Enter start date (YYYY-MM-DD) [default: ${firstDate}]: `)).trim() || firstDate;
+      const endAns = (await askQuestion(lines, `Enter end date (YYYY-MM-DD) [default: ${lastDate}]: `)).trim() || lastDate;
+      dateRangeVal = { start: startAns, end: endAns };
+    } else if (dateChoice === '4') {
+      dateFilterMode = 'LATEST';
+    } else {
+      dateFilterMode = 'ALL';
+    }
+  }
+
+  rl.close();
+
+  // Process selected verticals
+  logHeader('Processing & Generating DigiCampus Files');
+
+  for (const vert of targets) {
+    console.log(`\n${colors.bold}Vertical: ${vert.sheetName} - ${vert.verticalName}${colors.reset}`);
+    console.log(`  Students: ${colors.bold}${vert.students.length}${colors.reset}`);
+
+    let datesToExport = [...vert.dates];
+
+    if (dateFilterMode === 'SINGLE' && singleDateVal) {
+      datesToExport = datesToExport.filter(d => d.dateStr === singleDateVal);
+      if (datesToExport.length === 0) {
+        logWarn(`Date ${singleDateVal} was not found among instructional dates for ${vert.sheetName}.`);
+        const fallbackCol = vert.allDateColumns.find(d => d.dateStr === singleDateVal);
+        if (fallbackCol) {
+          datesToExport = [{ ...fallbackCol, presentCount: 0, absentCount: 0, totalStudents: vert.students.length }];
+        } else {
+          logError(`Date ${singleDateVal} does not exist in the spreadsheet!`);
+          continue;
+        }
+      }
+    } else if (dateFilterMode === 'RANGE' && dateRangeVal) {
+      datesToExport = datesToExport.filter(d => d.dateStr >= dateRangeVal.start && d.dateStr <= dateRangeVal.end);
+    } else if (dateFilterMode === 'LATEST' && datesToExport.length > 0) {
+      datesToExport = [datesToExport[datesToExport.length - 1]];
+    }
+
+    if (datesToExport.length === 0) {
+      logWarn(`No matching dates found to export for ${vert.sheetName}.`);
+      continue;
+    }
+
+    console.log(`  Dates to export: ${colors.bold}${datesToExport.length}${colors.reset}`);
+
+    const ws = workbook.Sheets[vert.sheetName];
+    const rows = xlsx.utils.sheet_to_json(ws, { header: 1, raw: true, defval: null });
+
+    // Build ZIP archive directly in memory
+    const zip = new AdmZip();
+
+    for (const dateItem of datesToExport) {
+      const fileName = `Upload_Attendance_${vert.sheetName}_${dateItem.dateStr}.xlsx`;
+      const outWb = generateDigiCampusWorkbook(vert, dateItem, rows);
+      const fileBuffer = xlsx.write(outWb, { type: 'buffer', bookType: 'xlsx' });
+      zip.addFile(fileName, fileBuffer);
+    }
+
+    // Save only the ZIP archive in output/
+    const zipFileName = `${vert.sheetName}_Attendance.zip`;
+    const zipFilePath = path.join(OUTPUT_DIR, zipFileName);
+    zip.writeZip(zipFilePath);
+
+    // Clean up any previously created unzipped folder for this vertical if it exists
+    const oldVertFolder = path.join(OUTPUT_DIR, `${vert.sheetName}_Attendance`);
+    if (fs.existsSync(oldVertFolder) && fs.statSync(oldVertFolder).isDirectory()) {
+      fs.rmSync(oldVertFolder, { recursive: true, force: true });
+    }
+
+    const zipStat = fs.statSync(zipFilePath);
+    const zipSizeKb = (zipStat.size / 1024).toFixed(1);
+
+    logSuccess(`Generated ZIP archive containing ${datesToExport.length} DigiCampus files:`);
+    console.log(`   ${colors.bold}${colors.green}${zipFilePath}${colors.reset} (${zipSizeKb} KB)`);
+  }
+
+  // Final summary
+  logHeader('Export Complete');
+  console.log(`Check the ${colors.bold}${colors.cyan}./output${colors.reset} directory for all generated files and ZIP archives.\n`);
+}
+
+main().catch(err => {
+  logError(`An unexpected error occurred: ${err.message}`);
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,36 @@
 {
   "name": "@mrselva/attendance",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.1.0",
+  "description": "Extract vertical attendance data and export into DigiCampus Excel templates with ZIP archive",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": [
+    "attendance",
+    "digicampus",
+    "excel",
+    "cli",
+    "npx"
+  ],
+  "author": "mrselva",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "attendance": "index.js"
+  },
+  "files": [
+    "index.js",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mrselva-eth/attendance.git"
+  },
+  "dependencies": {
+    "adm-zip": "^0.6.1",
+    "xlsx": "^0.18.5"
+  }
+}