@alien-protocol/cannon 2.2.2

package/src/index.js

@@ -0,0 +1,5 @@
+export { IssueCannon } from './cannon.js';
+export { loadIssues } from './loaders/index.js';
+export { createIssue, verifyToken } from './github.js';
+export { loadConfig } from './config.js';
+export { login, logout, status, getSavedToken } from './auth.js';

package/src/loaders/csv.js

@@ -0,0 +1,70 @@
+import fs from 'fs';
+import path from 'path';
+
+export async function loadCSV({ file }) {
+  if (!file) throw new Error('CSV loader requires `file` option');
+  const raw = fs.readFileSync(path.resolve(file), 'utf-8');
+  return parseCSV(raw);
+}
+
+// RFC-4180 CSV parser (handles quoted multi-line fields)
+export function parseCSV(raw) {
+  const rows = [];
+  let field = '',
+    inQuotes = false,
+    fields = [],
+    i = 0;
+  while (i < raw.length) {
+    const ch = raw[i],
+      next = raw[i + 1];
+    if (inQuotes) {
+      if (ch === '"' && next === '"') {
+        field += '"';
+        i += 2;
+      } else if (ch === '"') {
+        inQuotes = false;
+        i++;
+      } else {
+        field += ch;
+        i++;
+      }
+    } else {
+      if (ch === '"') {
+        inQuotes = true;
+        i++;
+      } else if (ch === ',') {
+        fields.push(field);
+        field = '';
+        i++;
+      } else if (ch === '\r' && next === '\n') {
+        fields.push(field);
+        rows.push(fields);
+        fields = [];
+        field = '';
+        i += 2;
+      } else if (ch === '\n') {
+        fields.push(field);
+        rows.push(fields);
+        fields = [];
+        field = '';
+        i++;
+      } else {
+        field += ch;
+        i++;
+      }
+    }
+  }
+  if (field || fields.length) {
+    fields.push(field);
+    if (fields.some((f) => f !== '')) rows.push(fields);
+  }
+  if (rows.length < 2) return [];
+  const headers = rows[0].map((h) => h.trim());
+  return rows.slice(1).map((row) => {
+    const obj = {};
+    headers.forEach((h, idx) => {
+      obj[h] = (row[idx] ?? '').trim();
+    });
+    return obj;
+  });
+}

package/src/loaders/docx.js

@@ -0,0 +1,45 @@
+import fs from 'fs';
+import path from 'path';
+import mammoth from 'mammoth';
+
+export async function loadDOCX({ file }) {
+  if (!file) throw new Error('DOCX loader requires `file` option');
+
+  const buffer = fs.readFileSync(path.resolve(file));
+
+  const { value: html } = await mammoth.convertToHtml({ buffer });
+
+  return parseHTMLTable(html);
+}
+
+function parseHTMLTable(html) {
+  // Simple regex-based table extractor (no DOM dep needed)
+  const rows = [...html.matchAll(/<tr[^>]*>([\s\S]*?)<\/tr>/gi)];
+  if (rows.length < 2) throw new Error('DOCX: No table found, or table has fewer than 2 rows');
+
+  const getCells = (rowHtml) =>
+    [...rowHtml.matchAll(/<t[dh][^>]*>([\s\S]*?)<\/t[dh]>/gi)].map((m) => stripTags(m[1]).trim());
+
+  const headers = getCells(rows[0][1]).map((h) => h.toLowerCase());
+
+  return rows
+    .slice(1)
+    .map((row) => {
+      const cells = getCells(row[1]);
+      const obj = {};
+      headers.forEach((h, i) => {
+        obj[h] = cells[i] ?? '';
+      });
+      return obj;
+    })
+    .filter((r) => r.title);
+}
+
+function stripTags(html) {
+  return html
+    .replace(/<[^>]+>/g, '')
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&nbsp;/g, ' ');
+}

package/src/loaders/index.js

@@ -0,0 +1,51 @@
+import { loadCSV } from './csv.js';
+import { loadPDF } from './pdf.js';
+import { loadDOCX } from './docx.js';
+import { loadJSON } from './json.js';
+import { loadPostgres } from './postgres.js';
+import { loadMySQL } from './mysql.js';
+import { loadSQLite } from './sqlite.js';
+
+const LOADERS = {
+  csv: loadCSV,
+  pdf: loadPDF,
+  docx: loadDOCX,
+  json: loadJSON,
+  postgres: loadPostgres,
+  mysql: loadMySQL,
+  sqlite: loadSQLite,
+  array: async (opts) => opts.data ?? [],
+};
+
+/**
+ * @param {{ source: string, [key: string]: any }} opts
+ * @returns {Promise<object[]>}
+ */
+export async function loadIssues(opts = {}) {
+  const { source, ...rest } = opts;
+  if (!source) throw new Error('loadIssues: `source` is required');
+
+  const loader = LOADERS[source.toLowerCase()];
+  if (!loader) {
+    throw new Error(
+      `Unknown source "${source}". Valid sources: ${Object.keys(LOADERS).join(', ')}`
+    );
+  }
+
+  const issues = await loader(rest);
+
+  // Normalise: ensure required fields exist
+  return issues.map((row, i) => {
+    if (!row.title) throw new Error(`Issue at index ${i} is missing "title"`);
+    if (!row.repo) throw new Error(`Issue "${row.title}" is missing "repo"`);
+    return {
+      repo: row.repo.trim(),
+      title: row.title.trim(),
+      body: row.body?.trim() ?? '',
+      labels: row.labels ?? '',
+      milestone: row.milestone?.trim() ?? '',
+      priority: row.priority?.trim() ?? '',
+      track: row.track?.trim() ?? '',
+    };
+  });
+}

package/src/loaders/json.js

@@ -0,0 +1,10 @@
+import fs from 'fs';
+import path from 'path';
+
+export async function loadJSON({ file }) {
+  if (!file) throw new Error('JSON loader requires `file` option');
+  const raw = fs.readFileSync(path.resolve(file), 'utf-8');
+  const data = JSON.parse(raw);
+  if (!Array.isArray(data)) throw new Error('JSON file must export an array of issue objects');
+  return data;
+}

package/src/loaders/mysql.js

@@ -0,0 +1,30 @@
+import mysql from 'mysql2/promise';
+
+export async function loadMySQL({ connectionString, host, user, password, database, query }) {
+  if (!query) throw new Error('mysql loader requires `query`');
+
+  const connOpts = connectionString
+    ? { uri: interpolateEnv(connectionString) }
+    : {
+        host: interpolateEnv(host ?? ''),
+        user: interpolateEnv(user ?? ''),
+        password: interpolateEnv(password ?? ''),
+        database: interpolateEnv(database ?? ''),
+      };
+
+  const connection = await mysql.createConnection(connOpts);
+  try {
+    const [rows] = await connection.execute(query);
+    return rows;
+  } finally {
+    await connection.end();
+  }
+}
+
+function interpolateEnv(str) {
+  return str.replace(/\$\{([^}]+)\}/g, (_, key) => {
+    const val = process.env[key];
+    if (!val) throw new Error(`Environment variable "${key}" is not set`);
+    return val;
+  });
+}

package/src/loaders/pdf.js

@@ -0,0 +1,62 @@
+import fs from 'fs';
+import path from 'path';
+import pdfParse from 'pdf-parse/lib/pdf-parse.js';
+
+export async function loadPDF({ file, strategy = 'auto' }) {
+  if (!file) throw new Error('PDF loader requires `file` option');
+
+  const buffer = fs.readFileSync(path.resolve(file));
+  const data = await pdfParse(buffer);
+  const text = data.text;
+
+  if (strategy === 'auto') {
+    // Heuristic: if most non-empty lines contain | or \t → table
+    const lines = text.split('\n').filter((l) => l.trim());
+    const delimited = lines.filter((l) => l.includes('|') || l.includes('\t'));
+    strategy = delimited.length > lines.length * 0.4 ? 'table' : 'text';
+  }
+
+  if (strategy === 'table') return parseTablePDF(text);
+  return parseTextPDF(text);
+}
+
+function parseTablePDF(text) {
+  const lines = text
+    .split('\n')
+    .map((l) => l.trim())
+    .filter(Boolean);
+  const sep = lines[0].includes('|') ? '|' : '\t';
+  const headers = lines[0].split(sep).map((h) => h.trim().toLowerCase());
+  return lines
+    .slice(1)
+    .map((line) => {
+      const cols = line.split(sep).map((c) => c.trim());
+      const obj = {};
+      headers.forEach((h, i) => {
+        obj[h] = cols[i] ?? '';
+      });
+      return obj;
+    })
+    .filter((r) => r.title);
+}
+
+function parseTextPDF(text) {
+  const blocks = text.split(/\n{2,}/);
+  return blocks
+    .map((block) => {
+      const get = (key) => {
+        const match = block.match(new RegExp(`^${key}:(.*)`, 'im'));
+        return match ? match[1].trim() : '';
+      };
+      return {
+        repo: get('REPO'),
+        title: get('TITLE'),
+        body: get('BODY'),
+        labels: get('LABELS'),
+        milestone: get('MILESTONE'),
+        priority: get('PRIORITY'),
+        track: get('TRACK'),
+      };
+    })
+    .filter((r) => r.repo && r.title);
+}

package/src/loaders/postgres.js

@@ -0,0 +1,32 @@
+import pg from 'pg';
+
+const { Client } = pg;
+
+export async function loadPostgres({ connectionString, query, ssl }) {
+  if (!connectionString) throw new Error('postgres loader requires `connectionString`');
+  if (!query) throw new Error('postgres loader requires `query`');
+
+  // Support ${ENV_VAR} interpolation in connectionString
+  const connStr = interpolateEnv(connectionString);
+
+  const client = new Client({
+    connectionString: connStr,
+    ssl: ssl ?? (connStr.includes('sslmode=require') ? { rejectUnauthorized: false } : false),
+  });
+
+  await client.connect();
+  try {
+    const result = await client.query(query);
+    return result.rows;
+  } finally {
+    await client.end();
+  }
+}
+
+function interpolateEnv(str) {
+  return str.replace(/\$\{([^}]+)\}/g, (_, key) => {
+    const val = process.env[key];
+    if (!val) throw new Error(`Environment variable "${key}" is not set`);
+    return val;
+  });
+}

package/src/loaders/sqlite.js

@@ -0,0 +1,32 @@
+import fs from 'fs';
+import path from 'path';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+
+export async function loadSQLite({ file, query }) {
+  if (!file) throw new Error('sqlite loader requires `file`');
+  if (!query) throw new Error('sqlite loader requires `query`');
+
+  const initSqlJs = require('sql.js');
+  const SQL = await initSqlJs();
+
+  const buffer = fs.readFileSync(path.resolve(file));
+  const db = new SQL.Database(buffer);
+
+  try {
+    const results = db.exec(query);
+    if (!results.length) return [];
+
+    const { columns, values } = results[0];
+    return values.map((row) => {
+      const obj = {};
+      columns.forEach((col, i) => {
+        obj[col] = row[i] ?? '';
+      });
+      return obj;
+    });
+  } finally {
+    db.close();
+  }
+}