supernaturalist 0.1.0

package/dist/cli.js

@@ -0,0 +1,1097 @@
+#!/usr/bin/env node
+
+// src/adapters/amp.ts
+import { readdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function getAmpThreadsDir() {
+  return join(
+    process.env["XDG_DATA_HOME"] ?? join(homedir(), ".local", "share"),
+    "amp",
+    "threads"
+  );
+}
+function ampAdapter() {
+  return {
+    name: "amp",
+    async *messages(options) {
+      const threadsDir = getAmpThreadsDir();
+      let files;
+      try {
+        files = await readdir(threadsDir);
+      } catch {
+        return;
+      }
+      const jsonFiles = files.filter((f) => f.endsWith(".json"));
+      for (const file of jsonFiles) {
+        const filePath = join(threadsDir, file);
+        const threadId = file.replace(".json", "");
+        try {
+          const raw = await readFile(filePath, "utf-8");
+          const thread = JSON.parse(raw);
+          if (!thread.messages || !Array.isArray(thread.messages)) {
+            continue;
+          }
+          for (const msg of thread.messages) {
+            if (msg.role !== "assistant") {
+              continue;
+            }
+            const text = extractText(msg.content);
+            if (!text) {
+              continue;
+            }
+            const timestamp = msg.timestamp ?? msg.createdAt ?? void 0;
+            if (options?.since && timestamp) {
+              const ts = new Date(timestamp);
+              if (ts < options.since) {
+                continue;
+              }
+            }
+            yield {
+              text,
+              timestamp,
+              session: threadId
+            };
+          }
+        } catch {
+        }
+      }
+    }
+  };
+}
+function extractText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    const parts = content.filter(
+      (p) => typeof p === "object" && p !== null && typeof p.text === "string"
+    ).map((p) => p.text);
+    return parts.length > 0 ? parts.join(" ") : null;
+  }
+  return null;
+}
+
+// src/adapters/claude.ts
+import { createReadStream } from "node:fs";
+import { readdir as readdir2, stat } from "node:fs/promises";
+import { createInterface } from "node:readline";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+var CLAUDE_DIR = join2(homedir2(), ".claude", "projects");
+function claudeAdapter() {
+  return {
+    name: "claude",
+    async *messages(options) {
+      const projectsDir = CLAUDE_DIR;
+      let projectDirs;
+      try {
+        projectDirs = await readdir2(projectsDir);
+      } catch {
+        return;
+      }
+      for (const projectDir of projectDirs) {
+        const projectPath = join2(projectsDir, projectDir);
+        const projectStat = await stat(projectPath);
+        if (!projectStat.isDirectory()) {
+          continue;
+        }
+        const entries = await readdir2(projectPath);
+        const jsonlFiles = entries.filter((f) => f.endsWith(".jsonl"));
+        for (const file of jsonlFiles) {
+          const filePath = join2(projectPath, file);
+          const session = file.replace(".jsonl", "");
+          const context = options?.since ? { session, project: projectDir, since: options.since } : { session, project: projectDir };
+          yield* parseClaudeJsonl(filePath, context);
+        }
+        const subdirs = entries.filter((f) => !f.includes("."));
+        for (const subdir of subdirs) {
+          const subagentsDir = join2(projectPath, subdir, "subagents");
+          try {
+            const subFiles = await readdir2(subagentsDir);
+            const subJsonl = subFiles.filter((f) => f.endsWith(".jsonl"));
+            for (const file of subJsonl) {
+              const context = options?.since ? {
+                session: `${subdir}/${file.replace(".jsonl", "")}`,
+                project: projectDir,
+                since: options.since
+              } : {
+                session: `${subdir}/${file.replace(".jsonl", "")}`,
+                project: projectDir
+              };
+              yield* parseClaudeJsonl(join2(subagentsDir, file), context);
+            }
+          } catch {
+          }
+        }
+      }
+    }
+  };
+}
+async function* parseClaudeJsonl(filePath, context) {
+  const rl = createInterface({
+    input: createReadStream(filePath, { encoding: "utf-8" }),
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    if (!line.trim()) {
+      continue;
+    }
+    try {
+      const entry = JSON.parse(line);
+      const text = extractAssistantText(entry);
+      if (!text) {
+        continue;
+      }
+      const timestamp = extractTimestamp(entry);
+      if (context.since && timestamp) {
+        const ts = new Date(timestamp);
+        if (ts < context.since) {
+          continue;
+        }
+      }
+      const message = timestamp ? {
+        text,
+        timestamp,
+        session: context.session,
+        project: context.project
+      } : {
+        text,
+        session: context.session,
+        project: context.project
+      };
+      yield message;
+    } catch {
+    }
+  }
+}
+function extractAssistantText(entry) {
+  if (entry["type"] === "assistant") {
+    const message = entry["message"];
+    if (!message) {
+      return null;
+    }
+    return contentToString(message["content"]);
+  }
+  if (entry["role"] === "assistant") {
+    return contentToString(entry["content"]);
+  }
+  return null;
+}
+function contentToString(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    const parts = content.filter(
+      (p) => typeof p === "object" && p !== null && p.type === "text"
+    ).map((p) => p.text);
+    return parts.length > 0 ? parts.join(" ") : null;
+  }
+  return null;
+}
+function extractTimestamp(entry) {
+  if (typeof entry["timestamp"] === "string") {
+    return entry["timestamp"];
+  }
+  if (typeof entry["createdAt"] === "string") {
+    return entry["createdAt"];
+  }
+  return null;
+}
+
+// src/adapters/cline.ts
+import { readdir as readdir3, readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
+function getClineTaskDirs() {
+  const dirs = [];
+  const vscodePaths = getVSCodeGlobalStoragePaths();
+  const extensionIds = ["saoudrizwan.claude-dev", "rooveterinaryinc.roo-cline"];
+  for (const basePath of vscodePaths) {
+    for (const extId of extensionIds) {
+      const tasksDir = join3(basePath, extId, "tasks");
+      if (existsSync(tasksDir)) {
+        dirs.push(tasksDir);
+      }
+    }
+  }
+  const clineStandalone = join3(homedir3(), ".cline", "data", "tasks");
+  if (existsSync(clineStandalone)) {
+    dirs.push(clineStandalone);
+  }
+  return dirs;
+}
+function getVSCodeGlobalStoragePaths() {
+  const paths = [];
+  if (process.platform === "darwin") {
+    paths.push(
+      join3(homedir3(), "Library", "Application Support", "Code", "User", "globalStorage"),
+      join3(homedir3(), "Library", "Application Support", "Code - Insiders", "User", "globalStorage"),
+      join3(homedir3(), "Library", "Application Support", "Cursor", "User", "globalStorage")
+    );
+  } else if (process.platform === "linux") {
+    const configBase = process.env["XDG_CONFIG_HOME"] ?? join3(homedir3(), ".config");
+    paths.push(
+      join3(configBase, "Code", "User", "globalStorage"),
+      join3(configBase, "Code - Insiders", "User", "globalStorage"),
+      join3(configBase, "Cursor", "User", "globalStorage")
+    );
+  } else {
+    const appData = process.env["APPDATA"] ?? join3(homedir3(), "AppData", "Roaming");
+    paths.push(
+      join3(appData, "Code", "User", "globalStorage"),
+      join3(appData, "Code - Insiders", "User", "globalStorage"),
+      join3(appData, "Cursor", "User", "globalStorage")
+    );
+  }
+  return paths;
+}
+function clineAdapter() {
+  return {
+    name: "cline",
+    async *messages(options) {
+      const taskDirs = getClineTaskDirs();
+      for (const tasksDir of taskDirs) {
+        let taskIds;
+        try {
+          taskIds = await readdir3(tasksDir);
+        } catch {
+          continue;
+        }
+        for (const taskId of taskIds) {
+          const taskDir = join3(tasksDir, taskId);
+          const taskStat = await stat2(taskDir).catch(() => null);
+          if (!taskStat?.isDirectory()) {
+            continue;
+          }
+          const historyFile = join3(taskDir, "api_conversation_history.json");
+          try {
+            const raw = await readFile2(historyFile, "utf-8");
+            const messages = JSON.parse(raw);
+            if (!Array.isArray(messages)) {
+              continue;
+            }
+            for (const msg of messages) {
+              if (msg.role !== "assistant") {
+                continue;
+              }
+              const text = extractText2(msg.content);
+              if (!text) {
+                continue;
+              }
+              const timestamp = msg.ts ?? void 0;
+              if (options?.since && timestamp) {
+                const ts = new Date(timestamp);
+                if (ts < options.since) {
+                  continue;
+                }
+              }
+              yield {
+                text,
+                session: taskId
+              };
+            }
+          } catch {
+          }
+        }
+      }
+    }
+  };
+}
+function extractText2(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    const parts = content.filter(
+      (p) => typeof p === "object" && p !== null && p.type === "text" && typeof p.text === "string"
+    ).map((p) => p.text);
+    return parts.length > 0 ? parts.join(" ") : null;
+  }
+  return null;
+}
+
+// src/adapters/codex.ts
+import { createReadStream as createReadStream2 } from "node:fs";
+import { readdir as readdir4, stat as stat3 } from "node:fs/promises";
+import { createInterface as createInterface2 } from "node:readline";
+import { homedir as homedir4 } from "node:os";
+import { join as join4 } from "node:path";
+var CODEX_SESSIONS_DIR = join4(homedir4(), ".codex", "sessions");
+function codexAdapter() {
+  return {
+    name: "codex",
+    async *messages(options) {
+      yield* walkCodexSessions(CODEX_SESSIONS_DIR, options);
+    }
+  };
+}
+async function* walkCodexSessions(dir, options) {
+  let entries;
+  try {
+    entries = await readdir4(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = join4(dir, entry);
+    const entryStat = await stat3(fullPath);
+    if (entryStat.isDirectory()) {
+      yield* walkCodexSessions(fullPath, options);
+    } else if (entry.endsWith(".jsonl")) {
+      const session = entry.replace(".jsonl", "");
+      const context = options?.since ? { session, since: options.since } : { session };
+      yield* parseCodexJsonl(fullPath, context);
+    }
+  }
+}
+async function* parseCodexJsonl(filePath, context) {
+  const rl = createInterface2({
+    input: createReadStream2(filePath, { encoding: "utf-8" }),
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    if (!line.trim()) {
+      continue;
+    }
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type !== "response_item") {
+        continue;
+      }
+      const payload = entry.payload;
+      if (!payload || payload.role !== "assistant") {
+        continue;
+      }
+      const text = extractText3(payload.content);
+      if (!text) {
+        continue;
+      }
+      if (context.since && entry.timestamp) {
+        const ts = new Date(entry.timestamp);
+        if (ts < context.since) {
+          continue;
+        }
+      }
+      const message = entry.timestamp ? { text, timestamp: entry.timestamp, session: context.session } : { text, session: context.session };
+      yield message;
+    } catch {
+    }
+  }
+}
+function extractText3(content) {
+  if (!Array.isArray(content)) {
+    return null;
+  }
+  const parts = content.filter(
+    (p) => typeof p === "object" && p !== null && (p.type === "output_text" || p.type === "text") && typeof p.text === "string"
+  ).map((p) => p.text);
+  return parts.length > 0 ? parts.join(" ") : null;
+}
+
+// src/adapters/opencode.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join5 } from "node:path";
+function getOpencodeDatabasePath() {
+  const xdgPath = join5(
+    process.env["XDG_DATA_HOME"] ?? join5(homedir5(), ".local", "share"),
+    "opencode",
+    "opencode.db"
+  );
+  if (existsSync2(xdgPath)) {
+    return xdgPath;
+  }
+  if (process.platform === "darwin") {
+    const macPath = join5(
+      homedir5(),
+      "Library",
+      "Application Support",
+      "opencode",
+      "opencode.db"
+    );
+    if (existsSync2(macPath)) {
+      return macPath;
+    }
+  }
+  return null;
+}
+function opencodeAdapter() {
+  return {
+    name: "opencode",
+    async *messages(options) {
+      const dbPath = getOpencodeDatabasePath();
+      if (!dbPath) {
+        return;
+      }
+      let db;
+      try {
+        const BetterSqlite3 = await import("better-sqlite3");
+        const Ctor = BetterSqlite3.default ?? BetterSqlite3;
+        db = new Ctor(dbPath, { readonly: true });
+      } catch {
+        console.warn(
+          "supernaturalist: better-sqlite3 not available, skipping OpenCode sessions"
+        );
+        return;
+      }
+      try {
+        yield* queryAssistantMessages(db, options);
+      } finally {
+        db.close();
+      }
+    }
+  };
+}
+function* queryAssistantMessages(db, options) {
+  let query = `
+    SELECT
+      m.session_id,
+      m.time_created,
+      json_extract(p.data, '$.text') as text
+    FROM message m
+    JOIN part p ON p.message_id = m.id
+    WHERE json_extract(m.data, '$.role') = 'assistant'
+      AND json_extract(p.data, '$.type') = 'text'
+  `;
+  if (options?.since) {
+    const sinceMs = options.since.getTime();
+    query += ` AND m.time_created >= ${sinceMs}`;
+  }
+  query += ` ORDER BY m.time_created ASC`;
+  const rows = db.prepare(query).all();
+  for (const row of rows) {
+    if (!row.text || !row.text.trim()) {
+      continue;
+    }
+    yield {
+      text: row.text,
+      timestamp: new Date(row.time_created).toISOString(),
+      session: row.session_id
+    };
+  }
+}
+
+// src/adapters/pi.ts
+import { createReadStream as createReadStream3 } from "node:fs";
+import { readdir as readdir5, stat as stat4 } from "node:fs/promises";
+import { createInterface as createInterface3 } from "node:readline";
+import { homedir as homedir6 } from "node:os";
+import { join as join6 } from "node:path";
+var PI_SESSIONS_DIR = join6(homedir6(), ".pi", "agent", "sessions");
+function piAdapter() {
+  return {
+    name: "pi",
+    async *messages(options) {
+      yield* walkPiSessions(PI_SESSIONS_DIR, options);
+    }
+  };
+}
+async function* walkPiSessions(dir, options, project) {
+  let entries;
+  try {
+    entries = await readdir5(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = join6(dir, entry);
+    const entryStat = await stat4(fullPath).catch(() => null);
+    if (!entryStat) {
+      continue;
+    }
+    if (entryStat.isDirectory()) {
+      yield* walkPiSessions(fullPath, options, project ?? entry);
+    } else if (entry.endsWith(".jsonl")) {
+      const session = entry.replace(".jsonl", "");
+      const context = options?.since ? { session, project, since: options.since } : { session, project };
+      yield* parsePiJsonl(fullPath, context);
+    }
+  }
+}
+async function* parsePiJsonl(filePath, context) {
+  const rl = createInterface3({
+    input: createReadStream3(filePath, { encoding: "utf-8" }),
+    crlfDelay: Infinity
+  });
+  let project = context.project;
+  for await (const line of rl) {
+    if (!line.trim()) {
+      continue;
+    }
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type === "session") {
+        project = entry.cwd ?? project;
+        continue;
+      }
+      if (entry.type !== "message") {
+        continue;
+      }
+      const message = entry.message;
+      if (!message || message.role !== "assistant") {
+        continue;
+      }
+      const text = contentToString2(message.content);
+      if (!text) {
+        continue;
+      }
+      const timestamp = typeof entry.timestamp === "string" ? entry.timestamp : typeof message.timestamp === "number" ? new Date(message.timestamp).toISOString() : void 0;
+      if (context.since && timestamp) {
+        const ts = new Date(timestamp);
+        if (ts < context.since) {
+          continue;
+        }
+      }
+      const record = timestamp ? project ? { text, timestamp, session: context.session, project } : { text, timestamp, session: context.session } : project ? { text, session: context.session, project } : { text, session: context.session };
+      yield record;
+    } catch {
+    }
+  }
+}
+function contentToString2(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    const parts = content.filter(
+      (p) => typeof p === "object" && p !== null && p.type === "text" && typeof p.text === "string"
+    ).map((p) => p.text);
+    return parts.length > 0 ? parts.join(" ") : null;
+  }
+  return null;
+}
+
+// src/adapters/zed.ts
+import { readdir as readdir6, readFile as readFile3 } from "node:fs/promises";
+import { existsSync as existsSync3 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { join as join7 } from "node:path";
+function getZedPaths() {
+  if (process.platform === "darwin") {
+    const base2 = join7(homedir7(), "Library", "Application Support", "Zed");
+    return {
+      conversations: join7(base2, "conversations"),
+      db: join7(base2, "db")
+    };
+  }
+  const base = join7(
+    process.env["XDG_DATA_HOME"] ?? join7(homedir7(), ".local", "share"),
+    "zed"
+  );
+  return {
+    conversations: join7(base, "conversations"),
+    db: join7(base, "db")
+  };
+}
+function zedAdapter() {
+  return {
+    name: "zed",
+    async *messages(options) {
+      const paths = getZedPaths();
+      yield* parseTextThreads(paths.conversations, options);
+      yield* parseAgentThreads(paths.db, options);
+    }
+  };
+}
+async function* parseTextThreads(dir, _options) {
+  if (!existsSync3(dir)) {
+    return;
+  }
+  let files;
+  try {
+    files = await readdir6(dir);
+  } catch {
+    return;
+  }
+  const jsonFiles = files.filter((f) => f.endsWith(".json"));
+  for (const file of jsonFiles) {
+    const filePath = join7(dir, file);
+    const session = file.replace(".json", "");
+    try {
+      const raw = await readFile3(filePath, "utf-8");
+      const conversation = JSON.parse(raw);
+      if (!conversation.messages || !Array.isArray(conversation.messages)) {
+        continue;
+      }
+      for (const msg of conversation.messages) {
+        if (msg.role !== "assistant") {
+          continue;
+        }
+        const text = typeof msg.content === "string" ? msg.content : null;
+        if (!text) {
+          continue;
+        }
+        yield {
+          text,
+          session
+        };
+      }
+    } catch {
+    }
+  }
+}
+async function* parseAgentThreads(dbDir, _options) {
+  if (!existsSync3(dbDir)) {
+    return;
+  }
+  let dbFiles;
+  try {
+    const entries = await readdir6(dbDir);
+    dbFiles = entries.filter((f) => f.endsWith(".db"));
+  } catch {
+    return;
+  }
+  if (dbFiles.length === 0) {
+    return;
+  }
+  let Database;
+  try {
+    const mod = await import("better-sqlite3");
+    Database = mod.default ?? mod;
+  } catch {
+    return;
+  }
+  for (const dbFile of dbFiles) {
+    const dbPath = join7(dbDir, dbFile);
+    let db;
+    try {
+      db = new Database(dbPath, { readonly: true });
+    } catch {
+      continue;
+    }
+    try {
+      const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all();
+      const tableNames = tables.map((t) => t.name);
+      const msgTable = tableNames.find(
+        (t) => t === "messages" || t === "thread_messages" || t.includes("message")
+      );
+      if (!msgTable) {
+        db.close();
+        continue;
+      }
+      const columns = db.prepare(`PRAGMA table_info("${msgTable}")`).all();
+      const colNames = columns.map((c2) => c2.name);
+      const hasRole = colNames.includes("role");
+      if (!hasRole) {
+        db.close();
+        continue;
+      }
+      const contentCol = colNames.includes("content") ? "content" : colNames.includes("body") ? "body" : "text";
+      const query = `SELECT "${contentCol}" as text FROM "${msgTable}" WHERE role = 'assistant'`;
+      const rows = db.prepare(query).all();
+      for (const row of rows) {
+        if (!row.text?.trim()) {
+          continue;
+        }
+        yield { text: row.text };
+      }
+    } catch {
+    } finally {
+      db.close();
+    }
+  }
+}
+
+// src/adapters/index.ts
+var ADAPTERS = {
+  claude: claudeAdapter,
+  codex: codexAdapter,
+  opencode: opencodeAdapter,
+  amp: ampAdapter,
+  cline: clineAdapter,
+  pi: piAdapter,
+  zed: zedAdapter
+};
+function createAdapter(name) {
+  const factory = ADAPTERS[name];
+  if (!factory) {
+    throw new Error(
+      `unknown adapter: ${name} (available: ${Object.keys(ADAPTERS).join(", ")})`
+    );
+  }
+  return factory();
+}
+function allAdapters() {
+  return Object.values(ADAPTERS).map((f) => f());
+}
+
+// src/detector/index.ts
+var WORDLIST = [
+  // === GHOST family (vivid) ===
+  { word: "ghost", intensity: "vivid", group: "ghost" },
+  { word: "ghosts", intensity: "vivid", group: "ghost" },
+  { word: "ghostly", intensity: "vivid", group: "ghost" },
+  { word: "ghosted", intensity: "vivid", group: "ghost" },
+  { word: "ghosting", intensity: "vivid", group: "ghost" },
+  { word: "ghostwriter", intensity: "subtle", group: "ghost" },
+  // === HAUNT family (ominous) ===
+  { word: "haunt", intensity: "ominous", group: "haunt" },
+  { word: "haunted", intensity: "ominous", group: "haunt" },
+  { word: "haunting", intensity: "ominous", group: "haunt" },
+  { word: "haunts", intensity: "ominous", group: "haunt" },
+  { word: "hauntings", intensity: "ominous", group: "haunt" },
+  // === CURSE family (ominous) ===
+  { word: "curse", intensity: "ominous", group: "curse" },
+  { word: "cursed", intensity: "ominous", group: "curse" },
+  { word: "curses", intensity: "ominous", group: "curse" },
+  { word: "cursing", intensity: "ominous", group: "curse" },
+  { word: "cursedness", intensity: "ominous", group: "curse" },
+  // === GHOUL family (vivid) ===
+  { word: "ghoul", intensity: "vivid", group: "ghoul" },
+  { word: "ghouls", intensity: "vivid", group: "ghoul" },
+  { word: "ghoulish", intensity: "vivid", group: "ghoul" },
+  // === GOBLIN family (vivid) ===
+  { word: "goblin", intensity: "vivid", group: "goblin" },
+  { word: "goblins", intensity: "vivid", group: "goblin" },
+  { word: "gobliny", intensity: "subtle", group: "goblin" },
+  // === SPECTER family (vivid) ===
+  { word: "specter", intensity: "vivid", group: "specter" },
+  { word: "specters", intensity: "vivid", group: "specter" },
+  { word: "spectral", intensity: "vivid", group: "specter" },
+  // === PHANTOM family (vivid) ===
+  { word: "phantom", intensity: "vivid", group: "phantom" },
+  { word: "phantoms", intensity: "vivid", group: "phantom" },
+  // === WRAITH family (ominous) ===
+  { word: "wraith", intensity: "ominous", group: "wraith" },
+  { word: "wraiths", intensity: "ominous", group: "wraith" },
+  { word: "wraithlike", intensity: "ominous", group: "wraith" },
+  // === APPARITION family (vivid) ===
+  { word: "apparition", intensity: "vivid", group: "apparition" },
+  { word: "apparitions", intensity: "vivid", group: "apparition" },
+  { word: "apparitional", intensity: "vivid", group: "apparition" },
+  // === POLTERGEIST family (ominous) ===
+  { word: "poltergeist", intensity: "ominous", group: "poltergeist" },
+  { word: "poltergeists", intensity: "ominous", group: "poltergeist" },
+  // === DEMON family (ominous) ===
+  { word: "demon", intensity: "ominous", group: "demon" },
+  { word: "demons", intensity: "ominous", group: "demon" },
+  { word: "demonic", intensity: "ominous", group: "demon" },
+  // === UNDEAD family (vivid) ===
+  { word: "undead", intensity: "vivid", group: "undead" },
+  { word: "lich", intensity: "ominous", group: "undead" },
+  { word: "liches", intensity: "ominous", group: "undead" },
+  { word: "revenant", intensity: "ominous", group: "undead" },
+  { word: "revenants", intensity: "ominous", group: "undead" },
+  // === ZOMBIE family (vivid) ===
+  { word: "zombie", intensity: "vivid", group: "zombie" },
+  { word: "zombies", intensity: "vivid", group: "zombie" },
+  { word: "zombified", intensity: "vivid", group: "zombie" },
+  { word: "zombifying", intensity: "vivid", group: "zombie" },
+  // === VAMPIRE family (ominous) ===
+  { word: "vampire", intensity: "ominous", group: "vampire" },
+  { word: "vampires", intensity: "ominous", group: "vampire" },
+  { word: "vampiric", intensity: "ominous", group: "vampire" },
+  { word: "vampirism", intensity: "ominous", group: "vampire" },
+  // === WEREWOLF family (ominous) ===
+  { word: "werewolf", intensity: "ominous", group: "werewolf" },
+  { word: "werewolves", intensity: "ominous", group: "werewolf" },
+  { word: "lycan", intensity: "ominous", group: "werewolf" },
+  { word: "lycans", intensity: "ominous", group: "werewolf" },
+  { word: "lycanthrope", intensity: "ominous", group: "werewolf" },
+  { word: "lycanthropy", intensity: "ominous", group: "werewolf" },
+  // === WITCH family (vivid) ===
+  { word: "witch", intensity: "vivid", group: "witch" },
+  { word: "witches", intensity: "vivid", group: "witch" },
+  { word: "witchcraft", intensity: "vivid", group: "witch" },
+  { word: "witchy", intensity: "subtle", group: "witch" },
+  // === WARLOCK family (vivid) ===
+  { word: "warlock", intensity: "vivid", group: "warlock" },
+  { word: "warlocks", intensity: "vivid", group: "warlock" },
+  // === SORCERY family (vivid) ===
+  { word: "sorcery", intensity: "vivid", group: "sorcery" },
+  { word: "sorcerer", intensity: "vivid", group: "sorcery" },
+  { word: "sorcerers", intensity: "vivid", group: "sorcery" },
+  { word: "sorcerous", intensity: "vivid", group: "sorcery" },
+  // === SPELL family (subtle) ===
+  { word: "spell", intensity: "subtle", group: "spell" },
+  { word: "spells", intensity: "subtle", group: "spell" },
+  { word: "spellbound", intensity: "vivid", group: "spell" },
+  { word: "spellbinding", intensity: "vivid", group: "spell" },
+  { word: "spellbook", intensity: "vivid", group: "spell" },
+  { word: "spellcasting", intensity: "vivid", group: "spell" },
+  // === HEX family (ominous) ===
+  { word: "hex", intensity: "ominous", group: "hex" },
+  { word: "hexed", intensity: "ominous", group: "hex" },
+  { word: "hexes", intensity: "ominous", group: "hex" },
+  { word: "hexing", intensity: "ominous", group: "hex" },
+  // === GRIMOIRE family (vivid) ===
+  { word: "grimoire", intensity: "vivid", group: "grimoire" },
+  { word: "grimoires", intensity: "vivid", group: "grimoire" },
+  // === ELDRITCH family (ominous) ===
+  { word: "eldritch", intensity: "ominous", group: "eldritch" },
+  { word: "eldritchy", intensity: "ominous", group: "eldritch" },
+  // === CURSED OBJECTS ===
+  { word: "hauntedhouse", intensity: "ominous", group: "haunt" },
+  { word: "hauntingly", intensity: "ominous", group: "haunt" },
+  { word: "cursedobject", intensity: "ominous", group: "curse" },
+  // === OTHER SUPERNATURAL ===
+  { word: "possessed", intensity: "ominous", group: "possession" },
+  { word: "possession", intensity: "ominous", group: "possession" },
+  { word: "possess", intensity: "ominous", group: "possession" },
+  { word: "exorcism", intensity: "ominous", group: "exorcism" },
+  { word: "exorcist", intensity: "ominous", group: "exorcism" },
+  { word: "seance", intensity: "vivid", group: "seance" },
+  { word: "s\xE9ance", intensity: "vivid", group: "seance" },
+  { word: "medium", intensity: "subtle", group: "medium" },
+  { word: "mediums", intensity: "subtle", group: "medium" },
+  { word: "ouija", intensity: "vivid", group: "ouija" },
+  { word: "hauntology", intensity: "subtle", group: "haunt" },
+  { word: "banshee", intensity: "vivid", group: "banshee" },
+  { word: "banshees", intensity: "vivid", group: "banshee" },
+  { word: "wight", intensity: "ominous", group: "undead" },
+  { word: "wights", intensity: "ominous", group: "undead" },
+  { word: "ghast", intensity: "ominous", group: "ghoul" },
+  { word: "ghasts", intensity: "ominous", group: "ghoul" },
+  { word: "hauntedness", intensity: "ominous", group: "haunt" },
+  { word: "spectrality", intensity: "vivid", group: "specter" },
+  { word: "spirit", intensity: "subtle", group: "spirit" },
+  { word: "spirits", intensity: "subtle", group: "spirit" },
+  { word: "spiritual", intensity: "subtle", group: "spirit" },
+  { word: "phantasm", intensity: "vivid", group: "phantom" },
+  { word: "phantasms", intensity: "vivid", group: "phantom" }
+];
+function collapseRepeats(text) {
+  return text.replace(/(.)\1+/g, "$1");
+}
+function buildPattern(words) {
+  const sorted = [...words].sort((a, b) => b.word.length - a.word.length);
+  const pattern = sorted.map((w) => escapeRegExp(w.word)).join("|");
+  return new RegExp(`\\b(${pattern})\\b`, "gi");
+}
+function escapeRegExp(word) {
+  return word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var DEFAULT_PATTERN = buildPattern(WORDLIST);
+var WORD_MAP = new Map(WORDLIST.map((w) => [w.word.toLowerCase(), w]));
+function detect(text) {
+  const matches = [];
+  const seen = /* @__PURE__ */ new Set();
+  runPattern(text, text.toLowerCase(), matches, seen);
+  const collapsed = collapseRepeats(text.toLowerCase());
+  if (collapsed !== text.toLowerCase()) {
+    runPattern(text, collapsed, matches, seen);
+  }
+  return { count: matches.length, matches };
+}
+function runPattern(_originalText, searchText, matches, seen) {
+  DEFAULT_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = DEFAULT_PATTERN.exec(searchText)) !== null) {
+    if (seen.has(match.index)) {
+      continue;
+    }
+    const word = match[0].toLowerCase();
+    const entry = WORD_MAP.get(word);
+    if (!entry) {
+      continue;
+    }
+    seen.add(match.index);
+    matches.push({
+      word,
+      index: match.index,
+      intensity: entry.intensity,
+      group: entry.group
+    });
+  }
+}
+
+// src/commands/scan.ts
+var c = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m"
+};
+var SPINNER_MESSAGES = [
+  "Summoning the archives",
+  "Scanning for hauntings",
+  "Listening for whispers",
+  "Consulting the grimoire",
+  "Cataloging the uncanny",
+  "Tracking spectral echoes",
+  "Measuring the eerie",
+  "Indexing the supernatural",
+  "Checking for curses",
+  "Counting the eldritch"
+];
+function createSpinner() {
+  let messageIdx = 0;
+  let dotCount = 0;
+  let timer = null;
+  return {
+    start() {
+      messageIdx = Math.floor(Math.random() * SPINNER_MESSAGES.length);
+      timer = setInterval(() => {
+        dotCount = (dotCount + 1) % 4;
+        const msg = SPINNER_MESSAGES[messageIdx % SPINNER_MESSAGES.length];
+        const dots = ".".repeat(dotCount || 1);
+        process.stdout.write(`\r  ${c.dim}${msg}${dots}${c.reset}   `);
+      }, 300);
+    },
+    update() {
+      messageIdx++;
+    },
+    stop() {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      process.stdout.write("\r" + " ".repeat(60) + "\r");
+    }
+  };
+}
+function parseArgs(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--agent" || arg === "-a") {
+      options.agent = args[++i];
+    } else if (arg === "--since" || arg === "-s") {
+      const val = args[++i];
+      if (val) {
+        options.since = new Date(val);
+        if (isNaN(options.since.getTime())) {
+          console.error(`invalid date: ${val}`);
+          process.exit(1);
+        }
+      }
+    } else if (arg === "--help" || arg === "-h") {
+      console.log(`supernaturalist scan \u2014 scan sessions for supernatural terms
+
+Options:
+  --agent, -a <name>   Scan only a specific agent (claude, codex, opencode, amp, cline, pi, zed)
+  --since, -s <date>   Only scan messages after this date (ISO 8601)
+  --help, -h           Show this help`);
+      process.exit(0);
+    }
+  }
+  return options;
+}
+async function scan(args) {
+  const options = parseArgs(args);
+  const adapters = options.agent ? [createAdapter(options.agent)] : allAdapters();
+  const spinner = createSpinner();
+  spinner.start();
+  const groupTally = {};
+  const variantTally = {};
+  let totalMessages = 0;
+  let totalFindings = 0;
+  const perAgent = {};
+  for (const adapter of adapters) {
+    let agentMessages = 0;
+    let agentFindings = 0;
+    spinner.update();
+    const adapterOptions = options.since ? { since: options.since } : void 0;
+    for await (const message of adapter.messages(adapterOptions)) {
+      totalMessages++;
+      agentMessages++;
+      const result = detect(message.text);
+      if (result.count > 0) {
+        totalFindings += result.count;
+        agentFindings += result.count;
+        for (const match of result.matches) {
+          groupTally[match.group] = (groupTally[match.group] ?? 0) + 1;
+          const variants = variantTally[match.group] ??= {};
+          variants[match.word] = (variants[match.word] ?? 0) + 1;
+        }
+      }
+    }
+    if (agentMessages > 0) {
+      perAgent[adapter.name] = { messages: agentMessages, findings: agentFindings };
+    }
+  }
+  spinner.stop();
+  console.log("");
+  console.log(`  ${c.bold}${c.magenta}supernaturalist${c.reset} ${c.dim}report${c.reset}`);
+  console.log(`  ${c.dim}${"\u2500".repeat(30)}${c.reset}`);
+  console.log("");
+  console.log(`  ${c.dim}agent messages scanned${c.reset}  ${c.bold}${totalMessages}${c.reset}`);
+  console.log(
+    `  ${c.dim}supernatural hits${c.reset} ${c.bold}${c.magenta}${totalFindings}${c.reset}`
+  );
+  const activeAgents = Object.entries(perAgent);
+  if (activeAgents.length > 1) {
+    console.log("");
+    console.log(`  ${c.bold}by agent${c.reset}`);
+    for (const [name, stats] of activeAgents) {
+      const rate = (stats.findings / stats.messages * 100).toFixed(1);
+      console.log(
+        `    ${c.cyan}${name.padEnd(10)}${c.reset} ${c.bold}${String(stats.findings).padStart(4)}${c.reset} ${c.dim}in ${stats.messages} messages (${rate}%)${c.reset}`
+      );
+    }
+  }
+  if (totalFindings > 0) {
+    const sorted = Object.entries(groupTally).sort(([, a], [, b]) => b - a);
+    console.log("");
+    console.log(`  ${c.bold}top terms${c.reset}`);
+    for (const [group, count] of sorted.slice(0, 10)) {
+      const variants = variantTally[group] ?? {};
+      const variantList = Object.entries(variants).sort(([, a], [, b]) => b - a).filter(([v]) => v !== group).slice(0, 15).map(([v, cnt]) => `${c.dim}${v}${c.reset} ${cnt}`).join(`${c.dim},${c.reset} `);
+      const suffix = variantList ? ` ${c.dim}(${c.reset}${variantList}${c.dim})${c.reset}` : "";
+      console.log(
+        `    ${c.yellow}${group.padEnd(12)}${c.reset} ${c.bold}${String(count).padStart(4)}${c.reset}${suffix}`
+      );
+    }
+  }
+  console.log("");
+  if (totalFindings === 0) {
+    console.log(`  ${c.green}all quiet. no supernatural traces found.${c.reset}`);
+    console.log("");
+  }
+}
+
+// src/cli.ts
+var COMMANDS = {
+  scan
+};
+function usage() {
+  console.log(`supernaturalist \u2014 analyze supernatural language in agent responses
+
+Usage:
+  supernaturalist <command> [options]
+
+Commands:
+  scan          Scan agent responses for supernatural terms
+
+Options:
+  --help, -h    Show this help message
+  --version     Show version
+
+Examples:
+  supernaturalist scan
+  supernaturalist scan --agent claude
+  supernaturalist scan --since 2025-01-01`);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  if (command === "--help" || command === "-h") {
+    usage();
+    process.exit(0);
+  }
+  if (command === "--version") {
+    console.log("0.1.0");
+    process.exit(0);
+  }
+  const handler = command ? COMMANDS[command] : void 0;
+  if (handler) {
+    await handler(args.slice(1));
+  } else {
+    await scan(args);
+  }
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map