infernoflow 0.35.5 → 0.35.6

package/dist/lib/commands/feedback.mjs

@@ -3,19 +3,33 @@
  *
  * Collects in-CLI feedback about infernoflow and optionally opens the web form.
  *
+ * Responses are:
+ *   1. Saved locally in ~/.infernoflow/feedback.json
+ *   2. POSTed to Formspree (free, no backend needed — Ron gets email per submission)
+ *
+ * To activate Formspree:
+ *   1. Go to https://formspree.io → create free account → New Form
+ *   2. Replace FORMSPREE_ENDPOINT below with your form URL (e.g. https://formspree.io/f/xabc1234)
+ *   3. Publish the package — submissions arrive in your email immediately
+ *
  * Usage:
  *   infernoflow feedback            Interactive 5-question survey
  *   infernoflow feedback --form     Open Google Form in browser
  *   infernoflow feedback --json     Print last stored feedback as JSON
  */
 
-import * as fs   from "node:fs";
-import * as path from "node:path";
-import * as os   from "node:os";
+import * as fs    from "node:fs";
+import * as path  from "node:path";
+import * as os    from "node:os";
+import * as https from "node:https";
 import * as readline from "node:readline";
 import { execSync } from "node:child_process";
 import { bold, cyan, gray, green, yellow, red } from "../ui/output.mjs";
 
+// ── Replace this URL with your Formspree form endpoint ───────────────────────
+// Get one free at https://formspree.io (50 submissions/mo free, emails you each response)
+const FORMSPREE_ENDPOINT = "https://formspree.io/f/infernoflow"; // placeholder
+
 const FEEDBACK_FORM_URL = "https://forms.gle/infernoflow-feedback"; // placeholder — replace with real form
 const FEEDBACK_FILE     = path.join(os.homedir(), ".infernoflow", "feedback.json");
 
@@ -48,6 +62,39 @@ const QUESTIONS = [
   },
 ];
 
+/**
+ * Fire-and-forget POST to Formspree.
+ * Formspree emails the form owner on each submission — zero backend needed.
+ */
+function sendToFormspree(record) {
+  try {
+    if (!FORMSPREE_ENDPOINT || FORMSPREE_ENDPOINT.includes("placeholder")) return;
+
+    const url  = new URL(FORMSPREE_ENDPOINT);
+    const body = JSON.stringify({
+      ...record.responses,
+      _subject:  `infernoflow feedback v${record.version}`,
+      _version:  record.version,
+      _ts:       record.ts,
+    });
+
+    const req = https.request({
+      hostname: url.hostname,
+      path:     url.pathname,
+      method:   "POST",
+      headers:  {
+        "Content-Type":   "application/json",
+        "Accept":         "application/json",
+        "Content-Length": Buffer.byteLength(body),
+      },
+      timeout: 5000,
+    });
+    req.on("error", () => {}); // never surface errors to the user
+    req.write(body);
+    req.end();
+  } catch {}
+}
+
 function saveFeedback(responses) {
   const dir = path.dirname(FEEDBACK_FILE);
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
@@ -120,6 +167,9 @@ async function runSurvey() {
 
   const record = saveFeedback(responses);
 
+  // Fire-and-forget cloud send (Formspree — Ron gets an email)
+  sendToFormspree(record);
+
   console.log(green("  ✔ Feedback saved — thank you!\n"));
   console.log(gray("  Stored in: ~/.infernoflow/feedback.json"));
   console.log(gray(`  Version: ${record.version}`));

package/dist/lib/telemetry.mjs

@@ -3,35 +3,43 @@
  *
  * Opt-in, fire-and-forget usage analytics.
  *
- * - Stored in ~/.infernoflow/telemetry.json
- * - Never enabled without explicit consent
- * - Never blocks the CLI — all sends are async / best-effort
- * - Never sends code, file contents, capability names, or personal data
- *   Only sends: command name, infernoflow version, Node version, OS platform
+ * What we collect (nothing else):
+ *   ✅ command name (e.g. "log", "switch")
+ *   ✅ anonymous install UUID (random, never linked to identity)
+ *   ✅ infernoflow version
+ *   ✅ Node version + OS platform
+ *   ✅ timezone (geography estimation only)
+ *   ✅ project type (frontend/backend/unknown — inferred from package.json)
+ *   ✅ IDE (from env variables)
+ *   ❌ no code, no file names, no personal data, no IP stored
  *
- * Consent is requested lazily on the first interactive infernoflow run
- * after install (if no consent decision is stored).
+ * Backend: PostHog free tier (50K events/mo free, EU-hosted available)
+ * Config:  ~/.infernoflow/telemetry.json
+ * Events:  ~/.infernoflow/events.jsonl  (local mirror)
+ *
+ * Consent is requested lazily after 3 interactive runs.
  */
 
-import * as fs   from "node:fs";
-import * as path from "node:path";
-import * as os   from "node:os";
+import * as fs    from "node:fs";
+import * as path  from "node:path";
+import * as os    from "node:os";
 import * as https from "node:https";
+import * as crypto from "node:crypto";
 
-const CONFIG_DIR    = path.join(os.homedir(), ".infernoflow");
+const CONFIG_DIR     = path.join(os.homedir(), ".infernoflow");
 const TELEMETRY_FILE = path.join(CONFIG_DIR, "telemetry.json");
 const EVENTS_FILE    = path.join(CONFIG_DIR, "events.jsonl");
 
-const ENDPOINT = "https://telemetry.infernoflow.dev/v1/event"; // placeholder
+// PostHog free tier — swap to your own project API key when ready
+// https://posthog.com → create free project → Settings → Project API Key
+const POSTHOG_HOST   = "https://app.posthog.com";
+const POSTHOG_KEY    = "phc_infernoflow_placeholder"; // replace with real key from PostHog dashboard
 
 // ── Config helpers ────────────────────────────────────────────────────────────
 
 function readConfig() {
-  try {
-    return JSON.parse(fs.readFileSync(TELEMETRY_FILE, "utf8"));
-  } catch {
-    return null;
-  }
+  try { return JSON.parse(fs.readFileSync(TELEMETRY_FILE, "utf8")); }
+  catch { return null; }
 }
 
 function writeConfig(data) {
@@ -39,105 +47,171 @@ function writeConfig(data) {
   fs.writeFileSync(TELEMETRY_FILE, JSON.stringify(data, null, 2), "utf8");
 }
 
-/** Returns true if the user has opted in */
+/** Generate a random anonymous install UUID — stored once, never changes */
+function generateInstallId() {
+  // Use crypto.randomUUID if available (Node 15.6+), else fallback
+  try { return crypto.randomUUID(); }
+  catch { return "ifl_" + crypto.randomBytes(16).toString("hex"); }
+}
+
+/** Get or create the persistent anonymous install ID */
+function getOrCreateInstallId() {
+  const cfg = readConfig() || {};
+  if (cfg.installId) return cfg.installId;
+  const installId = generateInstallId();
+  writeConfig({ ...cfg, installId });
+  return installId;
+}
+
 export function isTelemetryEnabled() {
-  const cfg = readConfig();
-  return cfg?.enabled === true;
+  return readConfig()?.enabled === true;
 }
 
-/** Returns true if the user has made a consent decision (either way) */
 export function hasConsentDecision() {
   const cfg = readConfig();
   return cfg !== null && typeof cfg.enabled === "boolean";
 }
 
+// ── Context detection ─────────────────────────────────────────────────────────
+
+function detectIde() {
+  if (process.env.CURSOR_SESSION)        return "cursor";
+  if (process.env.COPILOT_SESSION)       return "copilot";
+  if (process.env.CLAUDE_CODE_SESSION)   return "claude-code";
+  if (process.env.WINDSURF_SESSION)      return "windsurf";
+  if (process.env.TERM_PROGRAM === "vscode") return "vscode";
+  return "unknown";
+}
+
+function detectProjectType() {
+  try {
+    const pkg = JSON.parse(fs.readFileSync("package.json", "utf8"));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (deps["next"] || deps["nuxt"] || deps["remix"])       return "fullstack";
+    if (deps["react"] || deps["vue"] || deps["svelte"])      return "frontend";
+    if (deps["express"] || deps["fastify"] || deps["koa"])   return "backend";
+    if (deps["@angular/core"])                               return "frontend";
+    return "js";
+  } catch {
+    return "unknown";
+  }
+}
+
+function getTimezone() {
+  try { return Intl.DateTimeFormat().resolvedOptions().timeZone; }
+  catch { return "unknown"; }
+}
+
+function getVersion() {
+  try {
+    const pkgPath = path.resolve(path.dirname(new URL(import.meta.url).pathname), "../package.json");
+    return JSON.parse(fs.readFileSync(pkgPath, "utf8")).version;
+  } catch { return "unknown"; }
+}
+
 // ── Consent prompt ────────────────────────────────────────────────────────────
 
-/**
- * Silently skip if consent already given, or if running non-interactively.
- * Call this once at the start of each interactive CLI run.
- */
 export async function ensureTelemetryConsent() {
   if (hasConsentDecision()) return;
   if (!process.stdin.isTTY) return;
 
-  // Only ask after 3+ runs (let the user experience it first)
-  const cfg = readConfig() || {};
+  // Only ask after 3+ interactive runs — let the user experience it first
+  const cfg  = readConfig() || {};
   const runs = (cfg.runs || 0) + 1;
-  writeConfig({ ...cfg, runs, enabled: false }); // default off until explicit consent
+  writeConfig({ ...cfg, runs, enabled: false });
 
   if (runs < 3) return;
 
-  // Show one-time prompt
   const { createInterface } = await import("node:readline");
   const rl = createInterface({ input: process.stdin, output: process.stdout });
 
   const answer = await new Promise(resolve => {
     process.stdout.write(
       "\n  📡 Help improve infernoflow?\n" +
-      "  Share anonymous usage data (command names only — no code, no content).\n" +
-      "  Type 'y' to opt in, any other key to decline. You can change this later with: infernoflow telemetry on/off\n" +
+      "  Share anonymous usage data — command names, OS, timezone. No code. No personal data.\n" +
+      "  Type 'y' to opt in, anything else to decline.  (infernoflow telemetry off to change later)\n" +
       "  → "
     );
     rl.question("", resolve);
   });
   rl.close();
 
-  const enabled = answer.trim().toLowerCase() === "y";
-  writeConfig({ enabled, runs, decidedAt: new Date().toISOString() });
+  const enabled   = answer.trim().toLowerCase() === "y";
+  const installId = enabled ? generateInstallId() : null;
+  writeConfig({ enabled, installId, runs, decidedAt: new Date().toISOString() });
 
-  if (enabled) {
-    process.stdout.write("  ✔ Telemetry enabled — thank you! (infernoflow telemetry off to disable)\n\n");
-  } else {
-    process.stdout.write("  ✔ Got it — telemetry off. (infernoflow telemetry on to enable later)\n\n");
-  }
+  process.stdout.write(
+    enabled
+      ? "  ✔ Telemetry enabled — thank you! (infernoflow telemetry off to disable)\n\n"
+      : "  ✔ No problem — telemetry off. (infernoflow telemetry on to enable later)\n\n"
+  );
 }
 
 // ── Event tracking ────────────────────────────────────────────────────────────
 
-/** Get current package version */
-function getVersion() {
-  try {
-    const pkgPath = path.resolve(path.dirname(new URL(import.meta.url).pathname), "../package.json");
-    return JSON.parse(fs.readFileSync(pkgPath, "utf8")).version;
-  } catch {
-    return "unknown";
-  }
-}
-
 /**
  * Track a command invocation. Fire-and-forget — never throws, never blocks.
- * @param {string} command  The command name (e.g. "log", "switch", "recap")
+ * @param {string} command  e.g. "log", "switch", "recap"
  */
 export function trackEvent(command) {
   if (!isTelemetryEnabled()) return;
 
+  const installId = getOrCreateInstallId();
+
   const event = {
-    ts:      new Date().toISOString(),
+    ts:          new Date().toISOString(),
     command,
-    version: getVersion(),
-    node:    process.version,
-    os:      process.platform,
+    installId,                     // anonymous UUID — links events from same install
+    version:     getVersion(),
+    node:        process.version,
+    os:          process.platform,
+    timezone:    getTimezone(),    // geography (continent/country) estimation
+    ide:         detectIde(),
+    projectType: detectProjectType(),
   };
 
-  // Always append to local event log first
+  // 1. Mirror to local event log
   try {
     if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
     fs.appendFileSync(EVENTS_FILE, JSON.stringify(event) + "\n", "utf8");
   } catch {}
 
-  // Fire-and-forget HTTP POST (best effort — no await)
+  // 2. Fire-and-forget to PostHog
+  //    PostHog expects: { api_key, event, distinct_id, properties, timestamp }
+  _postHog(installId, command, event);
+}
+
+function _postHog(distinctId, eventName, props) {
   try {
-    const body = JSON.stringify(event);
-    const url  = new URL(ENDPOINT);
-    const req  = https.request({
+    const body = JSON.stringify({
+      api_key:     POSTHOG_KEY,
+      event:       eventName,
+      distinct_id: distinctId,
+      properties:  {
+        command:      props.command,
+        version:      props.version,
+        node:         props.node,
+        os:           props.os,
+        timezone:     props.timezone,
+        ide:          props.ide,
+        projectType:  props.projectType,
+        $lib:         "infernoflow-cli",
+      },
+      timestamp: props.ts,
+    });
+
+    const url = new URL(POSTHOG_HOST + "/capture/");
+    const req = https.request({
       hostname: url.hostname,
       path:     url.pathname,
       method:   "POST",
-      headers:  { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) },
-      timeout:  3000,
+      headers:  {
+        "Content-Type":   "application/json",
+        "Content-Length": Buffer.byteLength(body),
+      },
+      timeout: 3000,
     });
-    req.on("error", () => {}); // silently ignore all errors
+    req.on("error", () => {});  // never surface telemetry errors
     req.write(body);
     req.end();
   } catch {}
@@ -150,8 +224,9 @@ export async function telemetryCommand(args) {
   const sub = args[0];
 
   if (sub === "on") {
-    const cfg = readConfig() || {};
-    writeConfig({ ...cfg, enabled: true, decidedAt: new Date().toISOString() });
+    const cfg       = readConfig() || {};
+    const installId = cfg.installId || generateInstallId();
+    writeConfig({ ...cfg, enabled: true, installId, decidedAt: new Date().toISOString() });
     console.log(green("\n  ✔ Telemetry enabled — thank you for helping improve infernoflow!\n"));
     return;
   }
@@ -159,28 +234,30 @@ export async function telemetryCommand(args) {
   if (sub === "off") {
     const cfg = readConfig() || {};
     writeConfig({ ...cfg, enabled: false, decidedAt: new Date().toISOString() });
-    console.log(green("\n  ✔ Telemetry disabled.\n"));
+    console.log(green("\n  ✔ Telemetry disabled. No data will be sent.\n"));
     return;
   }
 
   if (sub === "status" || !sub) {
-    const cfg = readConfig();
-    const enabled = cfg?.enabled === true;
-    const decided = cfg?.decidedAt ? new Date(cfg.decidedAt).toLocaleDateString() : "never";
+    const cfg       = readConfig();
+    const enabled   = cfg?.enabled === true;
+    const decided   = cfg?.decidedAt ? new Date(cfg.decidedAt).toLocaleDateString() : "never";
+    const installId = cfg?.installId ? cfg.installId.slice(0, 12) + "…" : "none yet";
 
-    // Count local events
     let eventCount = 0;
     try {
-      const lines = fs.readFileSync(EVENTS_FILE, "utf8").split("\n").filter(Boolean);
-      eventCount = lines.length;
+      eventCount = fs.readFileSync(EVENTS_FILE, "utf8").split("\n").filter(Boolean).length;
     } catch {}
 
     console.log("\n  " + bold("🔥 infernoflow telemetry status") + "\n");
-    console.log("  Telemetry     " + (enabled ? green("enabled") : yellow("disabled")));
+    console.log("  Status        " + (enabled ? green("enabled") : yellow("disabled")));
+    console.log("  Install ID    " + gray(installId + "  (anonymous, never linked to identity)"));
     console.log("  Decided       " + gray(decided));
-    console.log("  Events logged " + gray(eventCount + " (local only until enabled)"));
-    console.log("  Data sent     " + gray("command name, infernoflow version, Node version, OS platform"));
-    console.log("  Data never    " + gray("code, file names, capability names, email, personal data"));
+    console.log("  Events stored " + gray(eventCount + " locally  →  " + (enabled ? "also sent to PostHog" : "not sent (disabled)")));
+    console.log("  Backend       " + gray("PostHog (EU-hosted, no IP stored)"));
+    console.log();
+    console.log("  " + bold("What we collect:") + "  " + gray("command, version, Node, OS, timezone, IDE, project type"));
+    console.log("  " + bold("What we never collect:") + "  " + gray("code, file names, capability names, email, personal data"));
     console.log();
     console.log(gray("  infernoflow telemetry on   — enable"));
     console.log(gray("  infernoflow telemetry off  — disable"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infernoflow",
-  "version": "0.35.5",
+  "version": "0.35.6",
   "description": "Persistent memory for AI coding sessions — captures what agents can't infer from code alone. Works with Copilot, Cursor, Claude, and Windsurf.",
   "type": "module",
   "bin": {
@@ -22,7 +22,11 @@
     "test:help": "node bin/infernoflow.mjs --help",
     "build": "node build.mjs",
     "prepublishOnly": "node build.mjs",
-    "inferno:promote-draft": "node scripts/inferno-promote-draft.mjs"
+    "inferno:promote-draft": "node scripts/inferno-promote-draft.mjs",
+    "postinstall": "node -e \"try{require('@scarf/scarf')}catch(e){}\" 2>/dev/null; exit 0"
+  },
+  "dependencies": {
+    "@scarf/scarf": "^1.3.0"
   },
   "keywords": [
     "ai",