Skip to content

chriscooning/formant / .cursor/skills/formant

formant

Verified

Generate interactive HTML forms from natural language. Use when the user wants to create a form, survey, questionnaire, registration page, or feedback form. Also use when mentioning Formant, form schemas, or form building.

FileKindSize
SKILL.mdskill md11.8 KB
schema-reference.mdmarkdown24.3 KB
templates/admin-local.htmlother26.8 KB
templates/responses-dashboard.htmlother20.3 KB

templates/admin-local.html

View on GitHub
<!DOCTYPE html>
<!--
  Local admin panel. Build placeholders: FORM_ID, FORM_TITLE, SCHEMA_JSON, ADMIN_PASSWORD_HASH.
  IndexedDB: form.html and admin.html must be in the same folder (same origin) to share IndexedDB.
-->
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>{{FORM_TITLE}} — Admin</title>
  <style>
    * { box-sizing: border-box; }
    body { font-family: system-ui, sans-serif; margin: 1rem; max-width: 1200px; }
    h1 { font-size: 1.25rem; margin-bottom: 0.5rem; }
    .meta { color: #666; font-size: 0.875rem; margin-bottom: 1rem; }
    .password-gate { margin-bottom: 1rem; display: flex; gap: 0.5rem; align-items: center; }
    .password-gate input { flex: 1; max-width: 300px; padding: 0.5rem; }
    .password-gate button { padding: 0.5rem 1rem; cursor: pointer; }
    .tabs { display: flex; gap: 0.25rem; margin-bottom: 1rem; }
    .tabs button { padding: 0.5rem 1rem; cursor: pointer; border: 1px solid #ccc; background: #f5f5f5; }
    .tabs button.active { background: #fff; border-bottom-color: #fff; margin-bottom: -1px; }
    .partial-filters { margin-bottom: 0.5rem; }
    .partial-filters select { padding: 0.25rem 0.5rem; }
    .load-section { margin-bottom: 1rem; }
    .load-section button { padding: 0.5rem 1rem; cursor: pointer; }
    .actions { margin-bottom: 1rem; }
    .actions button { margin-right: 0.5rem; padding: 0.5rem 1rem; cursor: pointer; }
    table { border-collapse: collapse; width: 100%; font-size: 0.875rem; }
    th, td { border: 1px solid #ccc; padding: 0.5rem; text-align: left; }
    th { background: #f5f5f5; }
    .error { color: #c00; margin: 0.5rem 0; }
    .analytics { margin-bottom: 1.5rem; }
    .analytics-range { display: flex; gap: 0.25rem; margin-bottom: 0.75rem; }
    .analytics-range button { padding: 0.35rem 0.75rem; cursor: pointer; border: 1px solid #ccc; background: #f5f5f5; font-size: 0.875rem; }
    .analytics-range button.active { background: #e0e8f0; border-color: #4a6fa5; }
    .analytics-chart-wrap { margin-bottom: 1rem; max-width: 800px; height: 200px; }
    .analytics-cards { display: grid; grid-template-columns: repeat(4, 1fr); gap: 0.75rem; margin-bottom: 1rem; }
    @media (max-width: 640px) { .analytics-cards { grid-template-columns: repeat(2, 1fr); } }
    .analytics-card { border: 1px solid #ccc; padding: 0.75rem; background: #fafafa; }
    .analytics-card .label { font-size: 0.75rem; color: #666; margin-bottom: 0.25rem; }
    .analytics-card .value { font-size: 1.25rem; font-weight: 600; }
    .analytics-dropoff { font-size: 0.875rem; color: #555; margin-bottom: 0.5rem; }
    .sheets-connect { margin-bottom: 1rem; padding: 0.75rem; border: 1px solid #ccc; background: #fafafa; }
    .sheets-connect button { padding: 0.5rem 1rem; cursor: pointer; }
    .sheets-connect .connected { color: #16a34a; }
    .sheets-connect .sheets-link { margin-left: 0.5rem; }
  </style>
  <script src="https://cdn.jsdelivr.net/npm/chart.js@4"></script>
</head>
<body>
  <h1>{{FORM_TITLE}} — Admin</h1>
  <div class="meta">Form ID: {{FORM_ID}}</div>

  <div id="passwordGate" class="password-gate">
    <input type="password" id="passwordInput" placeholder="Enter admin password" autocomplete="off">
    <button type="button" id="unlockBtn">Unlock</button>
  </div>

  <div id="mainContent" style="display:none;">
    <div id="analyticsSection" class="analytics">
      <div class="analytics-range">
        <button type="button" id="range7" class="active">7 days</button>
        <button type="button" id="range14">14 days</button>
        <button type="button" id="range30">30 days</button>
      </div>
      <div class="analytics-chart-wrap">
        <canvas id="analyticsChart"></canvas>
      </div>
      <div class="analytics-cards">
        <div class="analytics-card"><div class="label">Total Submissions</div><div class="value" id="cardSubmissions">—</div></div>
        <div class="analytics-card"><div class="label">Total Views</div><div class="value" id="cardViews">—</div></div>
        <div class="analytics-card"><div class="label">Completion Rate</div><div class="value" id="cardCompletion">—</div></div>
        <div class="analytics-card"><div class="label">Avg Completion Time</div><div class="value" id="cardAvgTime">—</div></div>
      </div>
      <div class="analytics-dropoff" id="dropoffLine"></div>
    </div>
    <div id="sheetsConnectSection" class="sheets-connect" style="display:none;">
      <div id="sheetsConnectContent"></div>
    </div>
    <div class="tabs">
      <button type="button" id="tabFull" class="active">Full submissions</button>
      <button type="button" id="tabPartial">Partial submissions</button>
    </div>
    <div id="partialFilters" class="partial-filters" style="display:none;">
      <label>Filter: </label>
      <select id="emailFilter">
        <option value="all">All</option>
        <option value="with">With email</option>
        <option value="without">Without email</option>
      </select>
    </div>
    <div class="load-section">
      <button type="button" id="loadBtn">Load responses</button>
    </div>
    <div id="error" class="error" style="display:none;"></div>
    <div class="actions" id="actions" style="display:none;">
      <button type="button" id="exportCsv">Export CSV</button>
      <button type="button" id="exportXlsx">Export XLSX</button>
    </div>
    <div id="tableWrap" style="overflow-x: auto;">
      <table id="table">
        <thead id="thead"></thead>
        <tbody id="tbody"></tbody>
      </table>
    </div>
  </div>

  <script type="application/json" id="schema-json">{{SCHEMA_JSON}}</script>
  <script src="https://cdn.sheetjs.com/xlsx-0.20.3/package/dist/xlsx.full.min.js"></script>

  <script>
(function() {
  const FORM_ID = "{{FORM_ID}}";
  const ADMIN_PASSWORD_HASH = "{{ADMIN_PASSWORD_HASH}}";
  const FORMANT_API_URL = "{{FORMANT_API_URL}}";
  const CONNECT_SHEETS_DOCS_URL = "{{CONNECT_SHEETS_DOCS_URL}}";

  const schemaEl = document.getElementById("schema-json");
  const SCHEMA_JSON = schemaEl ? (function(){ try { return JSON.parse(schemaEl.textContent || "{}"); } catch(e){ return {}; } })() : {};

  const NON_INPUT_TYPES = new Set(["welcome", "statement", "ending"]);
  function getInputFields(schema) {
    const fields = schema?.fields;
    if (!Array.isArray(fields)) return [];
    return fields.filter(f => f && typeof f.type === "string" && !NON_INPUT_TYPES.has(f.type));
  }

  function getEmailFieldId(schema) {
    const field = schema?.fields?.find(f => f && f.type === "email");
    return field?.id ?? null;
  }

  function hasEmail(answers, emailFieldId) {
    if (!emailFieldId) return false;
    const val = answers[emailFieldId];
    return typeof val === "string" && val.trim().length > 0;
  }

  const columns = getInputFields(SCHEMA_JSON).map(f => ({ id: f.id, title: f.title || f.id }));
  const emailFieldId = getEmailFieldId(SCHEMA_JSON);

  const passwordGate = document.getElementById("passwordGate");
  const mainContent = document.getElementById("mainContent");
  const passwordInput = document.getElementById("passwordInput");
  const unlockBtn = document.getElementById("unlockBtn");
  const tabFull = document.getElementById("tabFull");
  const tabPartial = document.getElementById("tabPartial");
  const partialFilters = document.getElementById("partialFilters");
  const emailFilter = document.getElementById("emailFilter");
  const loadBtn = document.getElementById("loadBtn");
  const errorEl = document.getElementById("error");
  const actionsEl = document.getElementById("actions");
  const thead = document.getElementById("thead");
  const tbody = document.getElementById("tbody");
  const exportCsvBtn = document.getElementById("exportCsv");
  const exportXlsxBtn = document.getElementById("exportXlsx");
  const range7 = document.getElementById("range7");
  const range14 = document.getElementById("range14");
  const range30 = document.getElementById("range30");

  let currentTab = "full";
  let analyticsDays = 7;
  let chartInstance = null;

  const SESSION_KEY = "formant_admin_unlocked";

  function isUnlocked() {
    try { return sessionStorage.getItem(SESSION_KEY) === "1"; } catch (_) { return false; }
  }

  async function verifyPassword(input, storedHash) {
    if (!storedHash) return true;
    const buf = new TextEncoder().encode(input);
    const hash = await crypto.subtle.digest("SHA-256", buf);
    const hex = Array.from(new Uint8Array(hash)).map(b => b.toString(16).padStart(2, "0")).join("");
    return hex === storedHash;
  }

  function setUnlocked(unlocked) {
    try { sessionStorage.setItem(SESSION_KEY, unlocked ? "1" : ""); } catch (_) {}
    passwordGate.style.display = unlocked ? "none" : "flex";
    mainContent.style.display = unlocked ? "block" : "none";
    if (unlocked) { loadBtn.click(); renderSheetsSection(); }
  }

  unlockBtn.addEventListener("click", async () => {
    const ok = await verifyPassword(passwordInput.value, ADMIN_PASSWORD_HASH);
    if (ok) { setUnlocked(true); showError(""); } else { showError("Invalid password"); }
  });
  passwordInput.addEventListener("keydown", (e) => { if (e.key === "Enter") unlockBtn.click(); });

  function showError(msg) {
    errorEl.textContent = msg;
    errorEl.style.display = msg ? "block" : "none";
  }

  tabFull.addEventListener("click", () => { currentTab = "full"; tabFull.classList.add("active"); tabPartial.classList.remove("active"); partialFilters.style.display = "none"; loadBtn.click(); });
  tabPartial.addEventListener("click", () => { currentTab = "partial"; tabPartial.classList.add("active"); tabFull.classList.remove("active"); partialFilters.style.display = "block"; loadBtn.click(); });
  emailFilter.addEventListener("change", () => loadBtn.click());

  const SHEETS_DB = "formant_sheets_config";
  const SHEETS_STORE = "urls";
  function openSheetsDB() {
    return new Promise((resolve, reject) => {
      const req = indexedDB.open(SHEETS_DB, 1);
      req.onerror = () => reject(req.error);
      req.onsuccess = () => resolve(req.result);
      req.onupgradeneeded = (e) => { e.target.result.createObjectStore(SHEETS_STORE, { keyPath: "formId" }); };
    });
  }
  async function getStoredSheetsUrl(formId) {
    try {
      const db = await openSheetsDB();
      return new Promise((resolve) => {
        const tx = db.transaction(SHEETS_STORE, "readonly");
        const req = tx.objectStore(SHEETS_STORE).get(formId);
        req.onsuccess = () => { db.close(); resolve(req.result || null); };
        req.onerror = () => { db.close(); resolve(null); };
      });
    } catch { return null; }
  }
  async function setStoredSheetsUrl(formId, config) {
    const db = await openSheetsDB();
    return new Promise((resolve, reject) => {
      const tx = db.transaction(SHEETS_STORE, "readwrite");
      tx.objectStore(SHEETS_STORE).put({ formId, url: config.url, spreadsheetUrl: config.spreadsheetUrl, connectedAt: config.connectedAt || new Date().toISOString() });
      tx.oncomplete = () => { db.close(); resolve(); };
      tx.onerror = () => { db.close(); reject(tx.error); };
    });
  }
  async function handleSheetsCallback() {
    const hash = (location.hash || "").replace(/^#/, "");
    if (!hash) return;
    const params = Object.fromEntries(new URLSearchParams(hash));
    const url = params.url;
    const spreadsheetUrl = params.spreadsheetUrl;
    const formId = params.formId;
    if (url && formId) {
      await setStoredSheetsUrl(formId, { url, spreadsheetUrl });
      history.replaceState(null, "", location.pathname);
      if (formId === FORM_ID && isUnlocked()) renderSheetsSection();
    }
    const err = params.error;
    if (err && isUnlocked()) { showError("Connect failed: " + (params.message || err)); }
  }
  async function renderSheetsSection() {
    const section = document.getElementById("sheetsConnectSection");
    const content = document.getElementById("sheetsConnectContent");
    if (!FORMANT_API_URL || !FORMANT_API_URL.trim()) { section.style.display = "none"; return; }
    const isFile = location.protocol === "file:";
    if (isFile) {
      section.style.display = "block";
      content.innerHTML = '<span class="error">Connect Google Sheet requires serving over HTTP. Run <code>npx serve .</code> in this folder.</span>';
      return;
    }
    let configured = false;
    try {
      const statusRes = await fetch(FORMANT_API_URL.replace(/\/$/, "") + "/api/connect-sheets/status");
      if (statusRes.ok) {
        const statusData = await statusRes.json();
        configured = !!statusData.configured;
      }
    } catch (_) { /* assume not configured on fetch error */ }
    section.style.display = "block";
    if (!configured) {
      const docsLink = CONNECT_SHEETS_DOCS_URL
        ? '<a href="' + CONNECT_SHEETS_DOCS_URL.replace(/&/g, "&amp;").replace(/"/g, "&quot;") + '" target="_blank" rel="noopener">Setup guide</a>'
        : "";
      content.innerHTML = '<strong>Connect to Google Sheet</strong><p>How to set up: Configure OAuth credentials in Google Cloud, then set secrets via your deployment platform. ' + docsLink + '</p>';
      return;
    }
    const stored = await getStoredSheetsUrl(FORM_ID);
    if (stored) {
      content.innerHTML = '<span class="connected">Connected.</span><a class="sheets-link" href="' + (stored.spreadsheetUrl || "#") + '" target="_blank" rel="noopener">View in Google Sheet</a>';
    } else {
      content.innerHTML = '<button type="button" id="connectSheetsBtn">Connect Google Sheet</button>';
      document.getElementById("connectSheetsBtn").addEventListener("click", async () => {
        try {
          const redirectUri = location.origin + location.pathname;
          const res = await fetch(FORMANT_API_URL.replace(/\/$/, "") + "/api/connect-sheets/init", {
            method: "POST",
            headers: { "Content-Type": "application/json" },
            body: JSON.stringify({ redirect_uri: redirectUri, form_id: FORM_ID, schema: SCHEMA_JSON })
          });
          if (!res.ok) { const j = await res.json().catch(() => ({})); throw new Error(j.error || res.statusText); }
          const data = await res.json();
          if (data.auth_url) location.href = data.auth_url;
          else throw new Error("No auth URL");
        } catch (e) { showError("Connect failed: " + (e.message || "Unknown")); }
      });
    }
  }

  const DB_NAME = "formant_local";
  const STORE_NAME = "responses";
  const DB_VERSION = 2;

  function openDB() {
    return new Promise((resolve, reject) => {
      const req = indexedDB.open(DB_NAME, DB_VERSION);
      req.onerror = () => reject(req.error);
      req.onsuccess = () => resolve(req.result);
      req.onupgradeneeded = (e) => {
        const db = e.target.result;
        const tx = e.target.transaction;
        if (e.oldVersion === 0) {
          db.createObjectStore(STORE_NAME, { keyPath: ["formId", "sessionId"] });
          return;
        }
        if (e.oldVersion < 2) {
          const oldStore = tx.objectStore(STORE_NAME);
          const getAllReq = oldStore.getAll();
          getAllReq.onsuccess = () => {
            const records = getAllReq.result || [];
            db.deleteObjectStore(STORE_NAME);
            const newStore = db.createObjectStore(STORE_NAME, { keyPath: ["formId", "sessionId"] });
            for (const r of records) {
              newStore.put({
                formId: r.formId,
                sessionId: r.id || r.sessionId,
                status: "completed",
                submittedAt: r.submittedAt,
                updatedAt: r.submittedAt,
                answers: r.answers || {},
                metadata: r.metadata || null
              });
            }
          };
        }
      };
    });
  }

  async function getCompletedFromLocal(formId) {
    const db = await openDB();
    return new Promise((resolve, reject) => {
      const tx = db.transaction(STORE_NAME, "readonly");
      const req = tx.objectStore(STORE_NAME).getAll();
      req.onsuccess = () => {
        db.close();
        resolve((req.result || []).filter(r => r.formId === formId && r.status === "completed")
          .sort((a,b) => (a.submittedAt||"").localeCompare(b.submittedAt||""))
          .map(r => ({ formId: r.formId, responseId: r.sessionId, status: "completed", submittedAt: r.submittedAt, answers: r.answers||{}, metadata: r.metadata })));
      };
      req.onerror = () => { db.close(); reject(req.error); };
    });
  }

  async function getPartialsFromLocal(formId) {
    const db = await openDB();
    return new Promise((resolve, reject) => {
      const tx = db.transaction(STORE_NAME, "readonly");
      const req = tx.objectStore(STORE_NAME).getAll();
      req.onsuccess = () => {
        db.close();
        let list = (req.result || []).filter(r => r.formId === formId && r.status === "in_progress")
          .sort((a,b) => (b.updatedAt||b.submittedAt||"").localeCompare(a.updatedAt||a.submittedAt||""));
        list = list.map(r => ({ formId: r.formId, responseId: r.sessionId, status: "in_progress", submittedAt: r.submittedAt, answers: r.answers||{}, metadata: Object.assign({}, r.metadata, { updatedAt: r.updatedAt }) }));
        resolve(list);
      };
      req.onerror = () => { db.close(); reject(req.error); };
    });
  }

  async function getAllFromLocalForAnalytics(formId) {
    const db = await openDB();
    return new Promise((resolve, reject) => {
      const tx = db.transaction(STORE_NAME, "readonly");
      const req = tx.objectStore(STORE_NAME).getAll();
      req.onsuccess = () => {
        db.close();
        resolve((req.result || []).filter(r => r.formId === formId));
      };
      req.onerror = () => { db.close(); reject(req.error); };
    });
  }

  function normaliseValue(v) {
    if (v == null) return "";
    if (Array.isArray(v)) return v.map(String).join(", ");
    if (typeof v === "boolean") return v ? "Yes" : "No";
    return String(v);
  }

  function escapeCsvField(value) {
    const s = String(value);
    if (s.includes(",") || s.includes('"') || s.includes("\n") || s.includes("\r")) return '"' + s.replace(/"/g, '""') + '"';
    return s;
  }

  function escapeHtml(s) {
    const d = document.createElement("div");
    d.textContent = s;
    return d.innerHTML;
  }

  function formatDuration(seconds) {
    if (seconds == null || typeof seconds !== "number" || isNaN(seconds)) return "—";
    if (seconds < 60) return Math.round(seconds) + "s";
    if (seconds < 3600) {
      const m = Math.floor(seconds / 60);
      const s = Math.round(seconds % 60);
      return s > 0 ? m + "m " + s + "s" : m + "m";
    }
    const h = Math.floor(seconds / 3600);
    const m = Math.floor((seconds % 3600) / 60);
    return m > 0 ? h + "h " + m + "m" : h + "h";
  }

  function formatNum(n) {
    if (n == null || typeof n !== "number" || isNaN(n)) return "—";
    return n.toLocaleString();
  }

  function getDateStr(iso) {
    if (!iso) return "";
    const m = iso.match(/^(\d{4}-\d{2}-\d{2})/);
    return m ? m[1] : "";
  }

  function buildHeaders(includeLastActivity) {
    const cols = columns.map(c => c.title);
    if (includeLastActivity) cols.push("Last activity");
    cols.push("Submitted At");
    return cols;
  }

  function renderTable(responses, includeLastActivity) {
    const headers = buildHeaders(includeLastActivity);
    window._responses = responses;
    thead.innerHTML = "<tr>" + headers.map(h => "<th>" + escapeHtml(h) + "</th>").join("") + "</tr>";
    tbody.innerHTML = responses.map(r => {
      const cells = columns.map(c => normaliseValue(r.answers[c.id]));
      if (includeLastActivity) cells.push(normaliseValue(r.metadata?.updatedAt));
      cells.push(r.submittedAt || "");
      return "<tr>" + cells.map(c => "<td>" + escapeHtml(String(c)) + "</td>").join("") + "</tr>";
    }).join("");
    actionsEl.style.display = responses.length > 0 ? "block" : "none";
  }

  function filterByEmail(responses, filter) {
    if (filter === "all" || !emailFieldId) return responses;
    if (filter === "with") return responses.filter(r => hasEmail(r.answers, emailFieldId));
    return responses.filter(r => !hasEmail(r.answers, emailFieldId));
  }

  async function loadLocalAnalytics() {
    try {
      const all = await getAllFromLocalForAnalytics(FORM_ID);
      const completed = all.filter(r => r.status === "completed");
      const partials = all.filter(r => r.status === "in_progress");
      const now = new Date();
      const start = new Date(now);
      start.setDate(start.getDate() - analyticsDays);
      const startStr = start.toISOString().slice(0, 10);

      const completedInRange = completed.filter(r => getDateStr(r.submittedAt) >= startStr);
      const partialsInRange = partials.filter(r => {
        const d = getDateStr(r.updatedAt || r.submittedAt);
        return d && d >= startStr;
      });
      const totalStarted = completedInRange.length + partialsInRange.length;
      const completionRate = totalStarted > 0 ? (completedInRange.length / totalStarted) * 100 : 0;

      let totalDuration = 0;
      let durationCount = 0;
      for (const r of completedInRange) {
        const d = (r.metadata && typeof r.metadata === "object") ? r.metadata.duration : null;
        if (typeof d === "number") { totalDuration += d; durationCount++; }
      }
      const avgDuration = durationCount > 0 ? totalDuration / durationCount : 0;

      const subsByDate = {};
      for (const r of completedInRange) {
        const d = getDateStr(r.submittedAt);
        if (d) subsByDate[d] = (subsByDate[d] || 0) + 1;
      }

      const series = [];
      for (let d = new Date(start); d <= now; d.setDate(d.getDate() + 1)) {
        const dateStr = d.toISOString().slice(0, 10);
        series.push({ date: dateStr, views: 0, submissions: subsByDate[dateStr] || 0 });
      }

      const lastFieldCounts = {};
      for (const r of partialsInRange) {
        const fid = (r.metadata && typeof r.metadata === "object") ? r.metadata.lastFieldId : null;
        if (fid) lastFieldCounts[fid] = (lastFieldCounts[fid] || 0) + 1;
      }
      let highestDropoff = null;
      let maxCount = 0;
      for (const [fid, cnt] of Object.entries(lastFieldCounts)) {
        if (cnt > maxCount) { maxCount = cnt; highestDropoff = { fieldId: fid, count: cnt }; }
      }
      const fieldTitleMap = {};
      for (const f of (SCHEMA_JSON.fields || [])) {
        if (f && f.id) fieldTitleMap[f.id] = f.title || f.id;
      }
      if (highestDropoff) highestDropoff.fieldTitle = fieldTitleMap[highestDropoff.fieldId] || highestDropoff.fieldId;

      document.getElementById("cardSubmissions").textContent = formatNum(completed.length);
      document.getElementById("cardViews").textContent = "—";
      if (completed.length === 0) {
        document.getElementById("cardCompletion").textContent = "—";
        document.getElementById("cardAvgTime").textContent = "—";
        document.getElementById("dropoffLine").textContent = "No form completions yet";
      } else {
        document.getElementById("cardCompletion").textContent = completionRate.toFixed(1) + "%";
        document.getElementById("cardAvgTime").textContent = formatDuration(avgDuration);
        document.getElementById("dropoffLine").textContent = highestDropoff
          ? 'Highest dropoff: "' + escapeHtml(highestDropoff.fieldTitle) + '" — ' + formatNum(highestDropoff.count) + " abandoned"
          : "No dropoff data yet";
      }

      if (chartInstance) chartInstance.destroy();
      const ctx = document.getElementById("analyticsChart");
      if (ctx && typeof Chart !== "undefined") {
        chartInstance = new Chart(ctx, {
          type: "line",
          data: {
            labels: series.map(s => s.date),
            datasets: [
              { label: "Submissions", data: series.map(s => s.submissions), borderColor: "#16a34a", backgroundColor: "rgba(22,163,74,0.1)", fill: true }
            ]
          },
          options: {
            responsive: true,
            maintainAspectRatio: false,
            scales: { y: { beginAtZero: true } },
            plugins: { legend: { position: "top" } }
          }
        });
      }
    } catch (_) {}
  }

  range7.addEventListener("click", () => { analyticsDays = 7; range7.classList.add("active"); range14.classList.remove("active"); range30.classList.remove("active"); loadLocalAnalytics(); });
  range14.addEventListener("click", () => { analyticsDays = 14; range14.classList.add("active"); range7.classList.remove("active"); range30.classList.remove("active"); loadLocalAnalytics(); });
  range30.addEventListener("click", () => { analyticsDays = 30; range30.classList.add("active"); range7.classList.remove("active"); range14.classList.remove("active"); loadLocalAnalytics(); });

  loadBtn.addEventListener("click", async () => {
    showError("");
    try {
      let responses;
      if (currentTab === "full") {
        responses = await getCompletedFromLocal(FORM_ID);
      } else {
        responses = await getPartialsFromLocal(FORM_ID);
        responses = filterByEmail(responses, emailFilter.value);
      }
      renderTable(responses, currentTab === "partial");
      loadLocalAnalytics();
    } catch (e) {
      showError("Failed to load: " + (e.message || "Unknown"));
    }
  });

  function downloadBlob(blob, filename) {
    const a = document.createElement("a");
    a.href = URL.createObjectURL(blob);
    a.download = filename;
    a.click();
    URL.revokeObjectURL(a.href);
  }

  function buildCsv(responses, includeLastActivity) {
    const headers = buildHeaders(includeLastActivity);
    const rows = [headers.map(escapeCsvField)];
    for (const r of responses) {
      const cells = columns.map(c => escapeCsvField(normaliseValue(r.answers[c.id])));
      if (includeLastActivity) cells.push(escapeCsvField(normaliseValue(r.metadata?.updatedAt)));
      cells.push(escapeCsvField(r.submittedAt || ""));
      rows.push(cells);
    }
    return rows.map(r => r.join(",")).join("\r\n");
  }

  exportCsvBtn.addEventListener("click", () => {
    const responses = window._responses || [];
    if (responses.length === 0) { showError("No data to export"); return; }
    const csv = buildCsv(responses, currentTab === "partial");
    downloadBlob(new Blob([csv], { type: "text/csv;charset=utf-8" }), "responses.csv");
  });

  exportXlsxBtn.addEventListener("click", () => {
    const responses = window._responses || [];
    if (responses.length === 0) { showError("No data to export"); return; }
    if (typeof XLSX === "undefined") { showError("XLSX library not loaded"); return; }
    const headers = buildHeaders(currentTab === "partial");
    const data = [headers];
    for (const r of responses) {
      const row = columns.map(c => normaliseValue(r.answers[c.id]));
      if (currentTab === "partial") row.push(normaliseValue(r.metadata?.updatedAt));
      row.push(r.submittedAt || "");
      data.push(row);
    }
    const ws = XLSX.utils.aoa_to_sheet(data);
    const wb = XLSX.utils.book_new();
    XLSX.utils.book_append_sheet(wb, ws, "Responses");
    downloadBlob(new Blob([XLSX.write(wb, { type: "array", bookType: "xlsx" })], { type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" }), "responses.xlsx");
  });

  handleSheetsCallback().then(function() {
    if (isUnlocked()) setUnlocked(true);
  });
})();
  </script>
</body>
</html>
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 194kUpdated Claude CodeCodexVerifiedInstall