harnery 0.0.1 → 0.2.0

package/src/lib/presence.ts

@@ -0,0 +1,154 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { NO_DATA } from "./format.ts";
+
+export type PresenceState = "mobile" | "office";
+export type PresenceSource = "hook" | "cli";
+
+export interface PresenceRecord {
+  state: PresenceState;
+  updated_at: string;
+  source: PresenceSource;
+}
+
+export interface PresenceRead {
+  state: PresenceState;
+  updated_at: string | null;
+  source: PresenceSource | null;
+  is_default: boolean;
+}
+
+const DEFAULT_STATE: PresenceState = "office";
+
+export function presenceFilePath(): string {
+  return join(homedir(), ".claude", "presence");
+}
+
+export function readPresence(): PresenceRead {
+  const path = presenceFilePath();
+  if (!existsSync(path)) {
+    return { state: DEFAULT_STATE, updated_at: null, source: null, is_default: true };
+  }
+  try {
+    const raw = readFileSync(path, "utf8").trim();
+    const parsed = JSON.parse(raw) as Partial<PresenceRecord>;
+    const state =
+      parsed.state === "mobile" || parsed.state === "office" ? parsed.state : DEFAULT_STATE;
+    const source = parsed.source === "hook" || parsed.source === "cli" ? parsed.source : null;
+    return {
+      state,
+      updated_at: typeof parsed.updated_at === "string" ? parsed.updated_at : null,
+      source,
+      is_default: false,
+    };
+  } catch {
+    return { state: DEFAULT_STATE, updated_at: null, source: null, is_default: true };
+  }
+}
+
+export function writePresence(state: PresenceState, source: PresenceSource): PresenceRecord {
+  const path = presenceFilePath();
+  const dir = dirname(path);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+  const record: PresenceRecord = {
+    state,
+    updated_at: new Date().toISOString(),
+    source,
+  };
+  const tmp = `${path}.tmp.${process.pid}.${Date.now()}`;
+  writeFileSync(tmp, `${JSON.stringify(record)}\n`);
+  renameSync(tmp, path);
+  return record;
+}
+
+export function clearPresence(): boolean {
+  const path = presenceFilePath();
+  if (!existsSync(path)) return false;
+  unlinkSync(path);
+  return true;
+}
+
+const CURLY_RE = /[‘’“”]/;
+const STRAIGHT_RE = /['"]/;
+const FENCED_BACKTICK_RE = /^```[\s\S]*?^```/gm;
+const FENCED_TILDE_RE = /^~~~[\s\S]*?^~~~/gm;
+const BLOCK_QUOTE_RE = /^>.*$/gm;
+
+/**
+ * Strip fenced code blocks and `>`-quoted lines from the prompt before
+ * scanning for quote characters. Pasted code or quoted prose with smart
+ * quotes is the most common contamination vector; it shouldn't influence
+ * presence inference. Inline code spans are intentionally left as-is.
+ */
+export function preprocessForDetection(prompt: string): string {
+  return prompt
+    .replace(FENCED_BACKTICK_RE, "")
+    .replace(FENCED_TILDE_RE, "")
+    .replace(BLOCK_QUOTE_RE, "");
+}
+
+/**
+ * Apply the detection rules to a prompt. Returns the inferred state, or null
+ * if the prompt carries no actionable signal (mixed quotes, no quotes + not
+ * short-trailing-space, etc.), in which case the caller should preserve
+ * current state.
+ *
+ * Rule order (first match wins):
+ *   1. Both curly AND straight present -> null (mixed)
+ *   2. Curly only -> mobile
+ *   3. Straight only -> office
+ *   4. <100 chars and ends with space -> mobile
+ *   5. Otherwise -> null
+ */
+export function detectFromPrompt(prompt: string): PresenceState | null {
+  const cleaned = preprocessForDetection(prompt);
+  const hasCurly = CURLY_RE.test(cleaned);
+  const hasStraight = STRAIGHT_RE.test(cleaned);
+
+  if (hasCurly && hasStraight) return null;
+  if (hasCurly) return "mobile";
+  if (hasStraight) return "office";
+  if (prompt.length < 100 && prompt.endsWith(" ")) return "mobile";
+  return null;
+}
+
+export interface DetectResult {
+  changed: boolean;
+  before: PresenceState;
+  after: PresenceState;
+  detected: PresenceState | null;
+}
+
+export function applyDetection(prompt: string): DetectResult {
+  const current = readPresence();
+  const detected = detectFromPrompt(prompt);
+  if (detected === null || detected === current.state) {
+    return { changed: false, before: current.state, after: current.state, detected };
+  }
+  writePresence(detected, "hook");
+  return { changed: true, before: current.state, after: detected, detected };
+}
+
+export function ageSeconds(updated_at: string | null): number | null {
+  if (!updated_at) return null;
+  const t = Date.parse(updated_at);
+  if (Number.isNaN(t)) return null;
+  return Math.max(0, Math.floor((Date.now() - t) / 1000));
+}
+
+export function formatAge(seconds: number | null): string {
+  if (seconds === null) return NO_DATA;
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h`;
+  return `${Math.floor(seconds / 86400)}d`;
+}

package/src/lib/readability/client.ts

@@ -0,0 +1,156 @@
+/// <reference path="./turndown-plugin-gfm.d.ts" />
+import { Readability } from "@mozilla/readability";
+import { JSDOM } from "jsdom";
+import TurndownService from "turndown";
+import { tables } from "turndown-plugin-gfm";
+
+/**
+ * HTML → clean markdown via Readability (main-content extraction) +
+ * Turndown (HTML → markdown).
+ *
+ * The library backing the `read` command.
+ */
+
+export interface ReadabilityOptions {
+  /** Base URL for resolving relative links. Default `http://local/`. */
+  url?: string;
+  /** CSS selector for content. Bypasses Readability when set. */
+  selector?: string;
+  /** Truncate output to N chars (0 = no limit). Default 100000. */
+  maxChars?: number;
+  /** Return cleaned HTML instead of markdown (debugging). */
+  raw?: boolean;
+}
+
+export interface ReadabilityResult {
+  /** Final output: markdown or cleaned HTML when `raw: true`. */
+  output: string;
+  /** Pre-truncation length so callers can report what was dropped. */
+  rawLength: number;
+  /** Article title from Readability (`null` when --selector is used). */
+  title: string | null;
+}
+
+const DEFAULT_MAX_CHARS = 100_000;
+
+/**
+ * Convert raw HTML to clean markdown.
+ *
+ * Throws if input is empty, the selector matches nothing, or Readability
+ * fails to find a main article (caller should retry with `selector`).
+ */
+export function htmlToMarkdown(html: string, opts: ReadabilityOptions = {}): ReadabilityResult {
+  if (!html.trim()) {
+    throw new Error("Empty HTML input");
+  }
+
+  const dom = new JSDOM(html, { url: opts.url ?? "http://local/" });
+  const doc = dom.window.document;
+  preprocessDom(doc);
+
+  let contentHtml: string;
+  let title: string | null = null;
+
+  if (opts.selector) {
+    const el = doc.querySelector(opts.selector);
+    if (!el) {
+      throw new Error(`Selector "${opts.selector}" matched nothing`);
+    }
+    contentHtml = el.outerHTML;
+  } else {
+    const article = new Readability(doc).parse();
+    if (!article) {
+      throw new Error(
+        "Readability found no main content. Try a CSS selector via the `selector` option.",
+      );
+    }
+    contentHtml = article.content ?? "";
+    title = article.title ?? null;
+  }
+
+  const maxChars = opts.maxChars ?? DEFAULT_MAX_CHARS;
+
+  if (opts.raw) {
+    const clean = postprocess(contentHtml, maxChars);
+    return { output: clean, rawLength: contentHtml.length, title };
+  }
+
+  const turndown = new TurndownService({
+    headingStyle: "atx",
+    codeBlockStyle: "fenced",
+    bulletListMarker: "-",
+  });
+  turndown.remove(["script", "style", "iframe", "noscript"]);
+  turndown.use(tables);
+  // GFM-spec strikethrough is `~~text~~`. turndown-plugin-gfm's bundled
+  // strikethrough emits single-tilde `~text~` for pre-spec compatibility,
+  // which most modern renderers (GitHub, VS Code, CommonMark with the
+  // strikethrough extension) don't recognize. Register our own.
+  turndown.addRule("strikethrough-gfm", {
+    filter: (node) =>
+      node.nodeName === "DEL" || node.nodeName === "S" || node.nodeName === "STRIKE",
+    replacement: (content) => `~~${content}~~`,
+  });
+  const markdown = turndown.turndown(contentHtml);
+  const out = postprocess(markdown, maxChars);
+  return { output: out, rawLength: markdown.length, title };
+}
+
+/**
+ * Two pre-Turndown / pre-Readability HTML fixups that target the
+ * highest-impact noise patterns we hit in real-world scrapes:
+ *
+ *   1. `<br>` inside table cells (`<th>`/`<td>`) → replace with a space.
+ *      turndown-plugin-gfm emits literal `\n` for `<br>` and that breaks
+ *      strict CommonMark renderers when it lands inside a markdown table
+ *      cell. GitHub tolerates it but the resulting markdown is uglier.
+ *
+ *   2. `<pre>` containing element children (e.g. syntax-highlighting
+ *      `<span>`-per-token) → collapse to plain textContent. Turndown's
+ *      bare-`<pre>` path treats element-rich `<pre>` blocks as inline
+ *      text and escapes `<`/`>`/`*`/etc, producing very noisy markdown
+ *      that no longer round-trips as code. The textContent of any
+ *      well-formed token-highlighted block IS the original code.
+ *
+ * Applied AFTER JSDOM parse but BEFORE Readability / selector extraction
+ * so both paths benefit. Both passes are no-ops on HTML that doesn't
+ * exhibit the pattern, so the cost on simple inputs is one DOM walk.
+ */
+function preprocessDom(doc: Document): void {
+  // (1) Flatten <br> inside table cells.
+  for (const br of Array.from(doc.querySelectorAll("td br, th br"))) {
+    br.replaceWith(doc.createTextNode(" "));
+  }
+  // (2) Collapse element-rich <pre> blocks to <pre><code>textContent</code>
+  //     so Turndown's fenced-code-block rule applies. Pure-text <pre> and
+  //     canonical <pre><code>...</code></pre> wrappers are left alone;
+  //     Turndown handles both correctly (the latter even with nested
+  //     syntax-highlighting spans inside the <code>, since the rule keys
+  //     on textContent). The bug case is element-rich <pre> WITHOUT a
+  //     <code> wrapper (per-token <span>s as direct pre children), which
+  //     Turndown otherwise treats as inline text and escapes every <, >,
+  //     *, etc.
+  for (const pre of Array.from(doc.querySelectorAll("pre"))) {
+    if (pre.children.length === 0) continue;
+    if (pre.children.length === 1 && pre.children[0]?.nodeName === "CODE") continue;
+    const text = pre.textContent ?? "";
+    while (pre.firstChild) pre.removeChild(pre.firstChild);
+    const code = doc.createElement("code");
+    code.appendChild(doc.createTextNode(text));
+    pre.appendChild(code);
+  }
+}
+
+function postprocess(text: string, maxChars: number): string {
+  let out = text
+    .split("\n")
+    .map((line) => line.replace(/[ \t]+$/, ""))
+    .join("\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+
+  if (maxChars > 0 && out.length > maxChars) {
+    out = `${out.slice(0, maxChars)}\n\n... [truncated from ${text.length} to ${maxChars} chars]`;
+  }
+  return out;
+}

package/src/lib/readability/index.ts

@@ -0,0 +1,5 @@
+export {
+  htmlToMarkdown,
+  type ReadabilityOptions,
+  type ReadabilityResult,
+} from "./client.js";

package/src/lib/readability/turndown-plugin-gfm.d.ts

@@ -0,0 +1,10 @@
+declare module "turndown-plugin-gfm" {
+  import type TurndownService from "turndown";
+
+  type Plugin = (service: TurndownService) => void;
+  export const gfm: Plugin;
+  export const tables: Plugin;
+  export const strikethrough: Plugin;
+  export const taskListItems: Plugin;
+  export const highlightedCodeBlock: Plugin;
+}