infernoflow 0.36.0 → 0.37.0

package/CHANGELOG.md

@@ -1,5 +1,76 @@
 # Changelog — infernoflow
 
+## Unreleased
+
+> Changes since v0.10.17
+
+### Added
+- Scarf analytics + telemetry UUID/timezone + feedback Formspree (v0.35.6)
+- cloud session memory sync (v0.35.4)
+- opt-in telemetry system (v0.35.3)
+- stunning switch output (v0.35.2)
+- infernoflow feedback command (v0.35.1)
+- auto-capture git hooks + log --auto/--quiet/--source (v0.35.0)
+- progressive disclosure — 5 core commands in --help, infernoflow commands shows full grouped list (v0.34.4)
+- npm metadata — AI-optimized description + 20 keywords for AI-native discovery (v0.34.3)
+- infernoflow uninstall — remove all infernoflow artifacts from a project (v0.34.1)
+- v0.34.0 — persistent memory layer: switch session-boundary-aware, README rewrite, build fix (Sprint 8+9+10)
+- infernoflow recap — end-of-session summary with session health score, unlogged git topics, and nudges (v0.33.7)
+- infernoflow ask — query session memory by keyword/type, gotchas surface first (v0.33.6)
+- infernoflow stats — value dashboard (memory, tokens injected, coverage, savings estimate) (v0.33.5)
+- end-to-end HTTP chain tracing — resolves outbound calls to route handlers (v0.33.4)
+- Sprint 4 — route discovery, HTTP URL extraction, entry point detection, --suggest (v0.33.3)
+- infernoflow init --lite (3 files) + infernoflow upgrade (lite → full) (v0.33.2)
+- infernoflow switch — AI agent handoff summary (v0.33.1)
+- session memory (infernoflow log) + design system tracker (infernoflow theme) — capture what AI can't infer from code (v0.33.0)
+- graph --html interactive SVG output; VS Code extension v0.5.0 with Capability Graph panel (v0.32.9)
+- VS Code extension v0.4.0 — save-triggered contract sync
+- ai setup numbered menu with env-var auto-detection (v0.32.3)
+- Sprint 18C/D — dogfood capabilities.json, doctor action list, init AI nudge (v0.32.0)
+- Sprint 18 — demo command, AI fallback nudges, test fix (v0.31.0)
+- Sprint 17 — infernoflow test + ai commands (v0.30.0)
+- Sprint 16C — infernoflow explain command (v0.29.0)
+- Sprint 16B — infernoflow scaffold command (v0.28.0)
+- Sprint 15 Liquid Layer + Sprint 16A/16D (v0.26-0.27)
+- auto-configure Claude Code MCP + allowedTools (v0.10.25)
+- add changelog and diff commands for enhanced version tracking
+- add VS Code + Cursor extension
+- add infernoflow publish command
+- bump to 0.10.18, fix duplicate infernoDir in suggest
+- add React-specific scanner for --adopt
+
+### Fixed
+- uninstall now removes all infernoflow artifacts completely (v0.34.2)
+- extension sidebar icon badge — switch to createTreeView so uncovered count shows on activity bar icon
+- graph crashes on toString() — use Map instead of plain object for funcIndex (v0.32.8)
+- check handles bare-array capabilities.json; scenario coverage is a warning not error (v0.32.7)
+- typo 'capabilityy' in explain file-path output
+- explain command now accepts file paths in addition to capability IDs (v0.32.6)
+- await import in non-async loadCapsAtRef causes syntax error (v0.32.5)
+- add missing resolveProvider export to providerRouter.mjs (v0.32.4)
+- Windows path bug in demo/watch/ci/monorepo/notify (v0.32.2)
+- doctor CLI check false positive on Windows (.cmd PATH resolution)
+
+### Changed
+- v0.37.0 — Windows unicode fix, memory-first init, hot files in switch, CLAUDE.md auto-update, health score tips, icon fix, cross-platform postinstall
+- wire Polar.sh Pro checkout — real payments live
+- point homepage to infernoflow.dev (v0.35.9)
+- activate Formspree feedback endpoint (v0.35.8)
+- activate PostHog EU telemetry (v0.35.7)
+- bump to 0.35.5 (0.35.4 already published)
+- rewrite README to reflect all capabilities (v0.32.5)
+- v0.32.1
+- bump to v0.32.0
+- bump version to 0.31.0
+- release 0.10.24
+- release 0.10.23
+- release 0.10.22
+- release 0.10.21
+- release 0.10.20
+- release 0.10.19
+
+
+
 ## 0.10.25 — 2026-04-22
 
 ### Added

package/dist/bin/infernoflow.mjs

@@ -1,4 +1,39 @@
 #!/usr/bin/env node
+
+// ── Windows PowerShell unicode fix ───────────────────────────────────────
+// Default PowerShell can't render box-drawing chars — patch stdout/stderr
+// to replace them with ASCII equivalents before any output happens.
+(function patchUnicodeForWindows() {
+  if (process.platform !== "win32") return;
+  if (process.env.WT_SESSION) return;   // Windows Terminal — supports unicode
+  if (process.env.ConEmuPID) return;    // ConEmu/Cmder
+  if (process.env.TERM_PROGRAM === "vscode") return; // VS Code terminal
+
+  const MAP = {
+    "─": "-", "━": "-", "═": "=",
+    "│": "|", "┃": "|", "║": "|",
+    "┌": "+", "┐": "+", "└": "+", "┘": "+",
+    "├": "+", "┤": "+", "┬": "+", "┴": "+", "┼": "+",
+    "·": "*", "→": "->", "←": "<-", "✔": "[OK]", "✓": "[OK]",
+    "✘": "[X]", "✗": "[X]", "⚠": "[!]", "ℹ": "[i]",
+  };
+  const RE = new RegExp(Object.keys(MAP).join("|"), "g");
+
+  function patch(stream) {
+    const orig = stream.write.bind(stream);
+    stream.write = function(chunk, ...args) {
+      if (typeof chunk === "string") chunk = chunk.replace(RE, c => MAP[c]);
+      else if (Buffer.isBuffer(chunk)) {
+        const s = chunk.toString("utf8").replace(RE, c => MAP[c]);
+        chunk = Buffer.from(s, "utf8");
+      }
+      return orig(chunk, ...args);
+    };
+  }
+  patch(process.stdout);
+  patch(process.stderr);
+})();
+
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";

package/dist/lib/commands/init.mjs

@@ -214,12 +214,98 @@ async function initLite(cwd, force) {
   console.log();
 }
 
+/** Default init: memory-only, asks for first gotcha, 60 seconds */
+async function initMemory(cwd, force, yes) {
+  const { bold, cyan, gray, green, yellow } = await import("../ui/output.mjs");
+
+  const infernoDir = path.join(cwd, "inferno");
+  const sessionsFile = path.join(infernoDir, "sessions.jsonl");
+  const configFile   = path.join(infernoDir, "config.json");
+
+  if (fs.existsSync(infernoDir) && !force) {
+    // Already initialized — just confirm and show commands
+    console.log("\n  " + bold("🔥 infernoflow") + gray(" — already set up\n"));
+    console.log("  " + green("✔") + " inferno/ found\n");
+    console.log("  Quick commands:");
+    console.log("  " + cyan("infernoflow log \"...\"") + gray("    — remember something"));
+    console.log("  " + cyan("infernoflow switch") + gray("         — handoff to next AI"));
+    console.log("  " + cyan("infernoflow recap") + gray("          — session summary\n"));
+    console.log(gray("  For contracts & CI gates: infernoflow init --mode full\n"));
+    return;
+  }
+
+  const projectName = detectProjectName(cwd);
+
+  console.log("\n  " + bold("🔥 infernoflow") + gray(" — let's get you set up (30 seconds)\n"));
+  console.log("  Detected: " + cyan(projectName) + "\n");
+
+  // Create inferno/ directory
+  fs.mkdirSync(infernoDir, { recursive: true });
+
+  // Write minimal config
+  fs.writeFileSync(configFile, JSON.stringify({
+    project: projectName,
+    version: "1",
+    mode: "memory",
+    created: new Date().toISOString(),
+  }, null, 2) + "\n", "utf8");
+
+  // Create empty sessions.jsonl
+  if (!fs.existsSync(sessionsFile)) {
+    fs.writeFileSync(sessionsFile, "", "utf8");
+  }
+
+  // Ask for first gotcha (skip if --yes or not TTY)
+  let gotcha = "";
+  if (!yes && process.stdin.isTTY) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    gotcha = await new Promise(resolve => {
+      rl.question(
+        "  " + gray("What should the next AI agent know about this project?\n  > "),
+        ans => { rl.close(); resolve(ans.trim()); }
+      );
+    });
+  }
+
+  if (gotcha) {
+    const entry = {
+      ts: new Date().toISOString(),
+      agent: "user",
+      type: "gotcha",
+      summary: gotcha,
+      source: "init",
+    };
+    fs.appendFileSync(sessionsFile, JSON.stringify(entry) + "\n", "utf8");
+    console.log("\n  " + green("✔") + " First gotcha logged!");
+  }
+
+  console.log("\n  " + green("✔") + " You're set up. Quick commands:\n");
+  console.log("  " + cyan("infernoflow log \"...\"") + gray("    — remember something"));
+  console.log("  " + cyan("infernoflow switch") + gray("         — generate handoff for next AI"));
+  console.log("  " + cyan("infernoflow recap") + gray("          — session summary\n"));
+  console.log(gray("  Tip: infernoflow switch --copy puts the handoff on your clipboard.\n"));
+  console.log(gray("  Want contracts & CI gates? Run: infernoflow init --mode full\n"));
+}
+
 export async function initCommand(args) {
   const cwd = process.cwd();
   const force = args.includes("--force") || args.includes("-f");
   const yes = args.includes("--yes") || args.includes("-y");
   const adopt = args.includes("--adopt");
 
+  // ── Memory-first default (no flags) — 60-second onboarding ───────────────
+  const modeArg = args.find(a => a.startsWith("--mode="))?.split("=")[1]
+    || (args.indexOf("--mode") !== -1 ? args[args.indexOf("--mode") + 1] : null);
+
+  const isFullMode = modeArg === "full" || modeArg === "contract";
+  const hasAdvancedFlag = adopt || args.includes("--template") || args.includes("--cursor-hooks")
+    || args.includes("--vscode-copilot-hooks") || args.includes("--lite");
+
+  if (!isFullMode && !hasAdvancedFlag) {
+    await initMemory(cwd, force, yes);
+    return;
+  }
+
   // ── Lite mode — tiny project, single directory, 3 files only ──────────────
   if (args.includes("--lite")) {
     await initLite(cwd, force);

package/dist/lib/commands/log.mjs

@@ -30,6 +30,67 @@ import { bold, cyan, gray, green, yellow, red } from "../ui/output.mjs";
 const INFERNO_DIR   = "inferno";
 const SESSIONS_FILE = path.join(INFERNO_DIR, "sessions.jsonl");
 
+/** Silently regenerate CLAUDE.md, .cursorrules, and copilot-instructions.md
+ *  after every log entry so AI agents always have fresh context. */
+function autoUpdateContextFiles() {
+  try {
+    const sessionsRaw = fs.existsSync(SESSIONS_FILE)
+      ? fs.readFileSync(SESSIONS_FILE, "utf8").split("\n").filter(Boolean)
+          .map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean)
+      : [];
+
+    const gotchas   = sessionsRaw.filter(e => e.type === "gotcha");
+    const decisions = sessionsRaw.filter(e => e.type === "decision");
+    const attempts  = sessionsRaw.filter(e => e.type === "attempt" && (e.result === "failed" || e.result === "partial"));
+
+    const lines = [
+      `# Project Context (auto-generated by infernoflow)`,
+      ``,
+      `> Last updated: ${new Date().toISOString()}`,
+      ``,
+    ];
+
+    if (gotchas.length) {
+      lines.push(`## ⚠️ Known Gotchas (Read These First)`, ``);
+      for (const g of gotchas) lines.push(`- ${g.summary}`);
+      lines.push(``);
+    }
+    if (decisions.length) {
+      lines.push(`## ✓ Decisions In Effect`, ``);
+      for (const d of decisions) lines.push(`- ${d.summary}`);
+      lines.push(``);
+    }
+    if (attempts.length) {
+      lines.push(`## ❌ Things That Don't Work (Don't Try These)`, ``);
+      for (const a of attempts) lines.push(`- ${a.summary}`);
+      lines.push(``);
+    }
+
+    const content = lines.join("\n");
+    const cwd = process.cwd();
+
+    // Update CLAUDE.md if it already exists (don't create unsolicited)
+    const claudeMd = path.join(cwd, "CLAUDE.md");
+    if (fs.existsSync(claudeMd)) {
+      fs.writeFileSync(claudeMd, content, "utf8");
+    }
+
+    // Update .cursorrules if Cursor is detected
+    const cursorrules = path.join(cwd, ".cursorrules");
+    if (fs.existsSync(cursorrules) || fs.existsSync(path.join(cwd, ".cursor"))) {
+      fs.writeFileSync(cursorrules, content, "utf8");
+    }
+
+    // Update copilot-instructions.md if .github exists
+    const copilotInstructions = path.join(cwd, ".github", "copilot-instructions.md");
+    if (fs.existsSync(path.join(cwd, ".github"))) {
+      fs.writeFileSync(copilotInstructions, content, "utf8");
+    }
+  } catch {
+    // Never surface errors to the user — this is background infrastructure
+  }
+}
+
 const VALID_TYPES   = ["note","attempt","decision","gotcha","preference","theme","handoff","error"];
 const VALID_RESULTS = ["worked","failed","partial","unknown"];
 
@@ -175,6 +236,9 @@ export async function logCommand(args) {
   const written = appendEntry(entry, { auto: autoFlag, quiet: quietFlag });
   if (!written) return; // auto mode, no inferno/ — skip silently
 
+  // Silently regenerate CLAUDE.md / .cursorrules / copilot-instructions.md
+  autoUpdateContextFiles();
+
   if (!quietFlag) {
     const typeLabel   = type !== "note" ? cyan(` [${type}]`) : "";
     const resultLabel = result ? gray(` → ${result}`) : "";

package/dist/lib/commands/recap.mjs

@@ -338,11 +338,32 @@ export async function recapCommand(rawArgs = []) {
     console.log(`${icon}  ${ok ? label : gray(label)}`);
   }
 
-  // Nudge if health is low
-  if (score < 60) {
-    console.log();
-    console.log(gray("  To improve: log at least one gotcha and one decision per session."));
-    console.log(gray("  Gotchas are the highest-value entries — they prevent repeated mistakes."));
+  // Actionable improvement tips
+  {
+    const gotchaCount   = sessionEntries.filter(e => e.type === "gotcha").length;
+    const decisionCount = sessionEntries.filter(e => e.type === "decision").length;
+    const tips = [];
+
+    if (gotchaCount === 0) {
+      tips.push(cyan("infernoflow log \"...\" --type gotcha") + gray("  — adds 35 pts"));
+    } else if (gotchaCount < 3 && score < 80) {
+      tips.push(gray(`  ${3 - gotchaCount} more gotcha(s) would push you higher`));
+    }
+    if (decisionCount === 0) {
+      tips.push(cyan("infernoflow log \"...\" --type decision") + gray("  — adds 25 pts"));
+    }
+    if (score >= 60 && score < 80) {
+      tips.push(gray("  Almost B! One more entry gets you there."));
+    }
+    if (score >= 80) {
+      tips.push(green("  Great session — your handoff will be excellent."));
+    }
+
+    if (tips.length) {
+      console.log();
+      console.log(gray("  How to improve:"));
+      for (const t of tips) console.log("  " + t);
+    }
   }
 
   // ── Next session tip ──────────────────────────────────────────────────────

package/dist/lib/commands/switch.mjs

@@ -136,6 +136,31 @@ function getGitDiffStat() {
   }
 }
 
+/** Get most-edited files from git this session */
+function getHotFiles(since) {
+  try {
+    const sinceArg = since && since.getTime() > 0
+      ? `--after="${since.toISOString()}"`
+      : "-10";
+    const raw = execSync(
+      `git log ${sinceArg} --name-only --pretty=format: 2>/dev/null`,
+      { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    if (!raw) return [];
+    const counts = {};
+    for (const line of raw.split("\n")) {
+      const f = line.trim();
+      if (f) counts[f] = (counts[f] || 0) + 1;
+    }
+    return Object.entries(counts)
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 5)
+      .map(([file, edits]) => ({ file, edits }));
+  } catch {
+    return [];
+  }
+}
+
 /** Get recent git commits in this session */
 function getGitCommits(since) {
   try {
@@ -208,6 +233,7 @@ function buildHandoff(toAgent, sinceArg, allFlag) {
   // Git data
   const commits    = getGitCommits(sessionStart.getTime() > 0 ? sessionStart : null);
   const diffStat   = getGitDiffStat();
+  const hotFiles   = getHotFiles(sessionStart.getTime() > 0 ? sessionStart : null);
 
   // Memory pool
   const pool      = sessions.length > 0 ? sessions : recentFallback;
@@ -289,6 +315,15 @@ function buildHandoff(toAgent, sinceArg, allFlag) {
     lines.push("");
   }
 
+  // ── Hot files — auto-detected from git ────────────────────────────────────
+  if (hotFiles.length) {
+    lines.push("## 📁 Hot Files This Session", "");
+    for (const { file, edits } of hotFiles) {
+      lines.push(`- \`${file}\` — ${edits} edit${edits !== 1 ? "s" : ""}`);
+    }
+    lines.push("");
+  }
+
   // ── Preferences ───────────────────────────────────────────────────────────
   if (prefs.length) {
     lines.push("## Developer preferences", "");
@@ -437,6 +472,7 @@ export async function switchCommand(args) {
   const theme          = readJSON(THEME_FILE);
   const contract       = readJSON(CONTRACT_FILE) || {};
   const commits        = getGitCommits(sessionStartNow.getTime() > 0 ? sessionStartNow : null);
+  const hotFilesNow    = getHotFiles(sessionStartNow.getTime() > 0 ? sessionStartNow : null);
   const ide            = detectIde();
   const pool           = sessionEntries.length > 0 ? sessionEntries : allEntriesNow.slice(-5);
   const openThreads    = findOpenThreads(pool);
@@ -454,6 +490,9 @@ export async function switchCommand(args) {
   console.log("  Memory        " + sessionEntries.length + " entries this session  (total: " + allEntriesNow.length + ")");
   if (openThreads.length) console.log("  Open threads  " + yellow(openThreads.length + " unresolved"));
   if (commits.length)    console.log("  Git commits   " + commits.length + " this session");
+  if (hotFilesNow.length) {
+    console.log("  Hot files     " + hotFilesNow.map(f => cyan(f.file)).join(", "));
+  }
   console.log("  Capabilities  " + (contract.capabilities || []).length + " registered");
   if (theme?.fonts?.primary) console.log("  Font          " + theme.fonts.primary);
   if (theme?.colors?.mode)   console.log("  Color mode    " + theme.colors.mode);

package/dist/lib/ui/output.mjs

@@ -1,5 +1,28 @@
 // Zero-dependency color/output utilities using ANSI codes
 
+// ── Terminal capability detection ─────────────────────────────────────────
+function supportsUnicode() {
+  if (process.platform === "win32") {
+    // Windows Terminal sets WT_SESSION
+    if (process.env.WT_SESSION) return true;
+    // ConEmu / Cmder
+    if (process.env.ConEmuPID) return true;
+    // VS Code integrated terminal
+    if (process.env.TERM_PROGRAM === "vscode") return true;
+    // Default cmd.exe / PowerShell — no unicode box drawing
+    return false;
+  }
+  return true; // Mac/Linux always support it
+}
+
+export const CHARS = supportsUnicode()
+  ? { h: "─", v: "│", tl: "┌", tr: "┐", bl: "└", br: "┘",
+      dot: "·", arrow: "→", check: "✔", cross: "✘", warn: "⚠", fire: "🔥" }
+  : { h: "-", v: "|", tl: "+", tr: "+", bl: "+", br: "+",
+      dot: "*", arrow: "->", check: "[OK]", cross: "[X]", warn: "[!]", fire: "**" };
+
+export const HR = CHARS.h.repeat(50);
+
 const c = {
   reset: "\x1b[0m",
   bold: "\x1b[1m",
@@ -38,17 +61,17 @@ function strip(str) {
 }
 
 export function header(text) {
-  const title = boldOrange("🔥 infernoflow") + gray(" — " + text);
+  const title = boldOrange(CHARS.fire + " infernoflow") + gray(" — " + text);
   console.log("\n" + title);
-  console.log(gray("─".repeat(50)));
+  console.log(gray(HR));
 }
 
-export function ok(msg)          { console.log("  " + green("✔") + " " + msg); }
+export function ok(msg)          { console.log("  " + green(CHARS.check) + " " + msg); }
 export function fail(msg, hint)  {
-  console.log("  " + red("✘") + " " + red(msg));
-  if (hint) console.log("      " + gray("→ " + hint));
+  console.log("  " + red(CHARS.cross) + " " + red(msg));
+  if (hint) console.log("      " + gray(CHARS.arrow + " " + hint));
 }
-export function warn(msg)        { console.log("  " + yellow("⚠") + " " + yellow(msg)); }
+export function warn(msg)        { console.log("  " + yellow(CHARS.warn) + " " + yellow(msg)); }
 export function info(msg)        { console.log("  " + cyan("ℹ") + " " + msg); }
 export function section(title)   { console.log("\n" + bold(white(title))); }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infernoflow",
-  "version": "0.36.0",
+  "version": "0.37.0",
   "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": {
@@ -15,7 +15,8 @@
     "dist/templates",
     "README.md",
     "CHANGELOG.md",
-    "dist/lib/templates"
+    "dist/lib/templates",
+    "scripts/postinstall.js"
   ],
   "scripts": {
     "test": "node scripts/smoke.mjs && node scripts/json-smoke.mjs && node scripts/json-negative-smoke.mjs && node scripts/implement-smoke.mjs && node scripts/adopt-smoke.mjs && node scripts/pr-impact-smoke.mjs && node scripts/sync-smoke.mjs && node scripts/run-smoke.mjs",
@@ -23,7 +24,7 @@
     "build": "node build.mjs",
     "prepublishOnly": "node build.mjs",
     "inferno:promote-draft": "node scripts/inferno-promote-draft.mjs",
-    "postinstall": "node -e \"try{require('@scarf/scarf')}catch(e){}\" 2>/dev/null; exit 0"
+    "postinstall": "node scripts/postinstall.js"
   },
   "dependencies": {
     "@scarf/scarf": "^1.3.0"

package/scripts/postinstall.js

@@ -0,0 +1,2 @@
+// Cross-platform postinstall — works on Windows, Mac, and Linux
+try { require('@scarf/scarf'); } catch (e) { /* silent — analytics are optional */ }