altalandi 0.4.0 → 0.6.0

package/client.mjs

@@ -12,17 +12,28 @@ const REQUEST_FIELDS = [
   "scoring",
   "glossary",
   "returnDiffs",
+  "contribute",
 ];
 
 export class AltalandiError extends Error {
-  constructor(message, { code = "ALTALANDI_ERROR", status } = {}) {
+  constructor(message, { code = "ALTALANDI_ERROR", status, retryAfterMs } = {}) {
     super(message);
     this.name = "AltalandiError";
     this.code = code;
     if (Number.isInteger(status)) this.status = status;
+    if (Number.isFinite(retryAfterMs)) this.retryAfterMs = retryAfterMs;
   }
 }
 
+/** Retry-After as milliseconds: delay-seconds or an HTTP date. */
+function retryAfterMs(response) {
+  const value = response?.headers?.get?.("retry-after");
+  if (!value) return undefined;
+  if (/^\s*\d+\s*$/.test(value)) return Number(value) * 1000;
+  const at = Date.parse(value);
+  return Number.isFinite(at) ? Math.max(0, at - Date.now()) : undefined;
+}
+
 export class MeaningVerificationError extends AltalandiError {
   constructor(verdict) {
     const changed = verdict === false;
@@ -175,7 +186,7 @@ export async function refine(text, options = {}) {
       const suffix = detail || statusText;
       throw new AltalandiError(
         `Altalandi API request failed (${status || "unknown status"})${suffix ? `: ${suffix}` : "."}`,
-        { code: "API_ERROR", status },
+        { code: "API_ERROR", status, retryAfterMs: retryAfterMs(response) },
       );
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "altalandi",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Native-sounding Icelandic from your terminal or AI agent: one-time login, a Claude Code skill, and meaning verification.",
   "type": "module",
   "main": "./client.mjs",
@@ -20,6 +20,9 @@
     "auth.mjs",
     "update.mjs",
     "report.mjs",
+    "batch.mjs",
+    "segment.mjs",
+    "web.mjs",
     "skill/SKILL.md",
     "client.mjs",
     "client.d.ts",
@@ -27,7 +30,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "test": "node --test test/cli.test.mjs test/client.test.mjs test/update.test.mjs test/auth.test.mjs"
+    "test": "node --test test/cli.test.mjs test/client.test.mjs test/update.test.mjs test/auth.test.mjs test/report.test.mjs test/segment.test.mjs test/web.test.mjs test/batch.test.mjs"
   },
   "keywords": [
     "icelandic",

package/report.mjs

@@ -6,8 +6,12 @@
 //   reportMarkdown()   the report file: input, output, every change with its
 //                      reason, and the verdict
 //   writeReport()      writes it to ./altalandi-reports/ (or ALTALANDI_REPORT_DIR)
+//   batchReportMarkdown() / writeBatchReport()
+//                      the one summary of a folder or site run (CLI only)
 //
-// Reports are opt-in (--report, or ALTALANDI_REPORT=1): they contain the text.
+// Single-text reports are opt-in (--report, or ALTALANDI_REPORT=1): they
+// contain the text. A folder or site run always writes its summary, since its
+// output files hold the same text anyway.
 
 import { mkdir, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
@@ -112,3 +116,286 @@ export async function writeReport(input, data, options = {}, dir) {
   await writeFile(path, reportMarkdown(input, data, options), "utf8");
   return path;
 }
+
+// ── The review block ─────────────────────────────────────────────────────────
+// One Markdown block an agent pastes into the chat as it is: verdict, the text
+// before and after, every change with its reason, what the call cost and what
+// is left. `--review` prints it; the MCP tool returns it. The agent does not
+// rebuild it from JSON, so every run looks the same.
+
+const REJECTION = [
+  ["MEANING DRIFT", "merkingin breyttist í endurskriftinni"],
+  ["HARD INVARIANT LOST", "tala, dagsetning, nafn eða neitun hefði glatast"],
+  ["UNVERIFIED", "ekki tókst að staðfesta að merkingin héldist"],
+  ["CANDIDATE VETO", "endurskriftin reyndist ekki betri en frumtextinn"],
+];
+
+export function rejectionText(reason) {
+  const raw = String(reason ?? "").trim();
+  if (!raw) return "";
+  const hit = REJECTION.find(([code]) => raw.toUpperCase().startsWith(code));
+  return hit ? `${hit[1][0].toUpperCase()}${hit[1].slice(1)} (${raw})` : raw;
+}
+
+/** 1688 → "1.688" (Icelandic thousands separator). */
+export function formatInt(n) {
+  return String(Math.round(Number(n))).replace(/\B(?=(\d{3})+(?!\d))/g, ".");
+}
+
+/** 487.5 → "487,50 kr.", 500 → "500 kr." */
+export function formatIsk(n) {
+  const v = Math.round(Number(n) * 100) / 100;
+  const sign = v < 0 ? "−" : "";
+  const abs = Math.abs(v);
+  const whole = formatInt(Math.trunc(abs));
+  const cents = Math.round((abs - Math.trunc(abs)) * 100);
+  return `${sign}${whole}${cents ? "," + String(cents).padStart(2, "0") : ""} kr.`;
+}
+
+const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : null);
+
+/**
+ * What the call cost and what is left. `data.billing` (sent by newer engines)
+ * is exact; otherwise the cost is the balance difference between /v1/me
+ * before and after the call, which parallel calls on the same account blur.
+ */
+export function costLines(data, before, after) {
+  if (data?.test) return ["- Prófunarlykill: ekkert var rukkað og ekkert líkan keyrði."];
+  const b = data?.billing || {};
+  let charged = num(b.chargedIsk);
+  const exact = charged != null;
+  if (charged == null && num(before?.balanceIsk) != null && num(after?.balanceIsk) != null) {
+    charged = Math.round((before.balanceIsk - after.balanceIsk) * 100) / 100;
+  }
+  const units = num(b.units);
+  const unitsText = units != null ? ` · ${formatInt(units)} einingar` : "";
+  const lines = [];
+  if (charged == null) lines.push(`- Þetta kall: kostnaður óþekktur${unitsText}`);
+  else if (charged < 0) lines.push(`- Þetta kall: ekki hægt að reikna (inneignin breyttist á meðan)${unitsText}`);
+  else if (charged === 0) lines.push(b.paidFrom === "credit"
+    ? `- Þetta kall: 0 kr. af inneign${unitsText}`
+    : `- Þetta kall: 0 kr., ókeypis dagskammtur${unitsText}`);
+  else lines.push(`- Þetta kall: ${formatIsk(charged)} af inneign${exact ? "" : " (mismunur á inneign fyrir og eftir)"}${unitsText}`);
+
+  const balance = num(b.balanceIsk) ?? num(after?.balanceIsk);
+  const left = num(b.freeUnitsLeftToday) ?? num(after?.freeUnitsLeftToday);
+  const daily = num(after?.freeDailyUnits) ?? num(before?.freeDailyUnits);
+  const parts = [];
+  if (balance != null) parts.push(`inneign ${formatIsk(balance)}`);
+  if (left != null && daily != null) parts.push(`ókeypis eftir í dag ${formatInt(left)} af ${formatInt(daily)} einingum`);
+  else if (left != null) parts.push(`ókeypis eftir í dag ${formatInt(left)} einingar`);
+  else if (daily != null && daily > 0) parts.push(`ókeypis ${formatInt(daily)} einingar á dag`);
+  if (parts.length) lines.push(`- Staða: ${parts.join(" · ")}`);
+  else lines.push("- Staða: náðist ekki að sækja (`npx altalandi whoami`)");
+  if (balance != null && balance < 50) lines.push("- Bæta við inneign: https://altalandi.is/portal");
+  return lines;
+}
+
+function clip(text, max) {
+  const s = String(text ?? "");
+  if (!max || s.length <= max) return { text: s, clipped: false };
+  const cut = s.lastIndexOf(" ", max);
+  return { text: s.slice(0, cut > max * 0.6 ? cut : max).trimEnd() + " …", clipped: true };
+}
+
+// A quoted line that starts with "#" or ">" would render as a heading or a
+// nested quote; escape that first character.
+const quote = (s) => String(s).split(/\r?\n/)
+  .map((l) => (l.trim() ? `> ${l.replace(/^(\s*)([#>])/, "$1\\$2")}` : ">")).join("\n");
+const inline = (s) => String(s ?? "").replace(/\s+/g, " ").trim().replace(/([\\`*_~[\]<>|#])/g, "\\$1");
+
+/**
+ * The block to show the user. `before`/`after` are /v1/me responses (either
+ * may be null). Long texts are shortened for the chat; `fullTextAt` names the
+ * file that holds the whole output.
+ */
+export function reviewMarkdown(input, data, { before = null, after = null, maxChars = 1500, maxChanges = 30, fullTextAt = "" } = {}) {
+  const q = data?.quality || {};
+  const outcome = outcomeOf(data);
+  const diffs = Array.isArray(data?.diffs) ? data.diffs : [];
+  const score = q.nativenessScore != null ? ` · innfæddni ${q.nativenessScore}/100` : "";
+  const out = [`**Altalandi:** ${VERDICT[outcome]}${score}`, ""];
+
+  const inText = clip(input, maxChars);
+  out.push("**Fyrir**", quote(inText.text), "");
+  const same = String(data?.output ?? "").trim() === String(input ?? "").trim();
+  if (same) {
+    out.push("**Eftir**", outcome === "refused" ? "> Óbreytt: upprunalega textanum var skilað." : "> Óbreytt.", "");
+  } else {
+    const outText = clip(data?.output, maxChars);
+    out.push("**Eftir**", quote(outText.text), "");
+    if (outText.clipped || inText.clipped) {
+      out.push(`_Textinn er styttur hér${fullTextAt ? `; allur textinn er í ${fullTextAt}` : ""}._`, "");
+    }
+  }
+
+  if (outcome === "refused" && data?.rejectionReason) {
+    out.push(`**Af hverju óbreytt:** ${inline(rejectionText(data.rejectionReason))}`, "");
+  }
+
+  if (diffs.length) {
+    out.push(`**Breytingar (${diffs.length})**`);
+    diffs.slice(0, maxChanges).forEach((d, i) => {
+      out.push(`${i + 1}. „${inline(d.before)}“ → „${inline(d.after)}“`);
+      if (d.reason) out.push(`   Ástæða: ${inline(d.reason)}`);
+    });
+    if (diffs.length > maxChanges) out.push(`   … og ${diffs.length - maxChanges} í viðbót (sjá \`--report\`).`);
+    out.push("");
+  } else if (data?.diffStatus === "translation" || (data?.sourceLang === "en" && !same)) {
+    out.push("**Breytingar:** þýðing úr ensku, svo allur textinn er nýr.", "");
+  } else if (!same && data?.diffStatus === "unavailable") {
+    out.push("**Breytingar:** textinn breyttist en listi yfir breytingar fékkst ekki. Berðu saman fyrir og eftir.", "");
+  } else if (outcome !== "refused") {
+    out.push("**Breytingar:** engar.", "");
+  }
+
+  // The refusal reason is already shown above; its warning repeats it.
+  const code = REJECTION.find(([c]) => String(data?.rejectionReason ?? "").toUpperCase().startsWith(c))?.[0];
+  const warnings = (Array.isArray(data?.warnings) ? data.warnings : [])
+    .filter((w) => !String(w).startsWith("TEST KEY") && !(code && String(w).toUpperCase().startsWith(code)));
+  if (warnings.length && outcome !== "rewritten") {
+    out.push("**Athugasemdir**", ...warnings.slice(0, 3).map((w) => `- ${inline(w)}`), "");
+  }
+
+  const term = data?.terminology;
+  if (term?.dictionaries?.length) {
+    // Offered is not used: only a term verified in the output (by form or BÍN
+    // lemma) is "í textanum"; a stem-only match is "líklega"; an older engine
+    // without `usage` is listed as offered. The caller's glossary wins.
+    const usage = (x) => x.status === "overridden" ? "overridden"
+      : x.usage ?? (x.inOutput === true ? "verified" : x.inOutput === false ? "absent" : "unchecked");
+    const tag = { verified: "í textanum", probable: "líklega í textanum", absent: "ekki notað",
+                  unchecked: "boðið", overridden: "þitt orðasafn gekk framar" };
+    const shown = (term.terms || []).filter((x) => !x.inText);
+    out.push(`**Fagmál:** ${inline(term.dictionaries.map((d) => d.name).join(", "))}`);
+    if (!shown.some((x) => x.status !== "overridden")) out.push("- Engin fagorð áttu við þennan texta.");
+    shown.slice(0, 12).forEach((x) => {
+      const u = usage(x);
+      const is = u === "verified" || u === "probable" ? (x.used ?? x.is) : x.is;
+      out.push(`- ${inline(x.source)} → ${inline(is)} (${tag[u]})`);
+    });
+    if (shown.length > 12) out.push(`- … og ${shown.length - 12} í viðbót`);
+    out.push("");
+  }
+
+  out.push("**Kostnaður**", ...costLines(data, before, after));
+  if (data?.id) out.push(`- Auðkenni: \`${data.id}\``);
+  return out.join("\n") + "\n";
+}
+
+// ── folder and site runs ────────────────────────────────────────────────────
+
+const MEANING = {
+  passed: "staðfest",
+  changed: "gæti hafa breyst",
+  reverted: "endurskrift hafnað",
+  skipped: "ekki athuguð",
+  unavailable: "athugun lauk ekki",
+};
+const FILE_STATE = {
+  written: "breytt",
+  unchanged: "óbreytt eftir yfirferð",
+  copy: "afrituð án yfirferðar",
+  unfinished: "ekki kláruð, ekki skrifuð",
+  "over-budget": "utan --max-chars, ekki skrifuð",
+  failed: "villa",
+};
+const count = (n) => formatInt(n || 0);
+
+/** The one summary of a folder or site run: every file, every changed passage
+ *  (before and after, with the meaning verdict) and, under their own heading,
+ *  the passages that keep the original text because a check did not pass. */
+export function batchReportMarkdown(summary) {
+  const t = summary?.totals || {};
+  const files = Array.isArray(summary?.files) ? summary.files : [];
+  const when = String(summary?.finishedAt || new Date().toISOString()).replace("T", " ").slice(0, 19);
+  const fileStates = [
+    `${count(t.written)} breyttar`,
+    `${count(t.unchanged)} óbreyttar eftir yfirferð`,
+    `${count(t.copied)} afritaðar án yfirferðar`,
+    t.unfinished ? `${count(t.unfinished)} ekki kláraðar` : "",
+    t.overBudget ? `${count(t.overBudget)} utan --max-chars` : "",
+  ].filter(Boolean).join(", ");
+  const out = [
+    `# Altalandi: ${cell(summary?.input)} → ${cell(summary?.output)}`,
+    "",
+    "| | |", "|---|---|",
+    `| Tími | ${when} UTC |`,
+    `| Inntak | ${cell(summary?.input)} |`,
+    `| Úttak | ${cell(summary?.output)} |`,
+    `| Skrár | ${count(t.files)}: ${fileStates} |`,
+    `| Kaflar | ${count(t.passages)}: ${count(t.changed)} breyttir, ${count(t.unchangedPassages)} þurftu ekki breytingu, `
+      + `${count(t.kept)} héldu frumtextanum, ${count(t.failed)} mistókust |`,
+    `| Stafir sendir | ${count(t.characters)} |`,
+    `| Tegund texta | ${cell(summary?.domain || "general")} |`,
+    `| Málsnið | ${cell(summary?.register || "neutral")} |`,
+  ];
+
+  if (summary?.stopped) {
+    const done = files.filter((f) => f.status === "written" || f.status === "unchanged").map((f) => f.path);
+    const open = files.filter((f) => f.status === "unfinished").map((f) => f.path);
+    out.push("", "## Keyrslan stöðvaðist", "", cell(summary.stopped.message), "",
+      `- Kláraðar skrár (${done.length}): ${done.map(cell).join(", ") || "engar"}`,
+      `- Ekki kláraðar, ekki skrifaðar (${open.length}): ${open.map(cell).join(", ") || "engar"}`);
+  }
+
+  const rows = (status) => files.flatMap((f) => (f.passages || []).filter((p) => p.status === status).map((p) => ({ f, p })));
+  const kept = rows("kept");
+  if (kept.length) {
+    out.push("", `## Frumtextinn látinn standa (${kept.length})`, "",
+      "Athugunin stóðst ekki í þessum köflum, svo frumtextinn er óbreyttur í úttakinu. "
+        + "Tillagan fylgir svo þú getir metið hana.",
+      "", "| Skrá | # | Frumtexti | Tillaga (ekki notuð) | Ástæða |", "|---|---|---|---|---|");
+    for (const { f, p } of kept) {
+      out.push(`| ${cell(f.path)} | ${p.n} | ${cell(p.before)} | ${cell(p.after ?? "")} | ${cell(p.reason || MEANING[p.meaningCheck] || "")} |`);
+    }
+  }
+  const failed = rows("failed");
+  if (failed.length) {
+    out.push("", `## Villur (${failed.length})`, "", "Þessi köll mistókust, svo frumtextinn er óbreyttur.", "",
+      "| Skrá | # | Frumtexti | Villa |", "|---|---|---|---|");
+    for (const { f, p } of failed) out.push(`| ${cell(f.path)} | ${p.n} | ${cell(p.before)} | ${cell(p.reason)} |`);
+  }
+
+  const changedFiles = files.filter((f) => (f.passages || []).some((p) => p.status === "changed"));
+  out.push("", "## Breytingar eftir skrám");
+  if (!changedFiles.length) out.push("", "Engar breytingar.");
+  for (const f of changedFiles) {
+    const changed = f.passages.filter((p) => p.status === "changed");
+    out.push("", `### ${cell(f.path)}`, "");
+    if (f.source) out.push(`Heimild: ${f.source}`, "");
+    out.push(`Breyttir kaflar: ${count(changed.length)} af ${count(f.passages.length)}.`, "",
+      "| # | Fyrir | Eftir | Merking |", "|---|---|---|---|");
+    for (const p of changed) out.push(`| ${p.n} | ${cell(p.before)} | ${cell(p.after)} | ${MEANING[p.meaningCheck] || "?"} |`);
+  }
+
+  const quiet = files.filter((f) => !changedFiles.includes(f));
+  if (quiet.length) {
+    out.push("", "## Skrár án breytinga", "");
+    for (const f of quiet) out.push(`- ${cell(f.path)}: ${FILE_STATE[f.status] || f.status}${f.note ? ` (${cell(f.note)})` : ""}`);
+  }
+  if (Array.isArray(summary?.skippedPages) && summary.skippedPages.length) {
+    out.push("", "## Síður sem voru ekki lesnar", "");
+    for (const s of summary.skippedPages) out.push(`- ${s.url}: ${cell(s.reason)}`);
+  }
+  return out.join("\n") + "\n";
+}
+
+/** Write the summary of a folder or site run; returns its path. */
+export async function writeBatchReport(summary, dir) {
+  const base = resolve(dir || process.env.ALTALANDI_REPORT_DIR || join(process.cwd(), "altalandi-reports"));
+  await mkdir(base, { recursive: true });
+  const stamp = new Date().toISOString().replace(/[-:]/g, "").replace("T", "-").slice(0, 15);
+  // A folder is named by its own name, a URL by its host and path.
+  const input = String(summary?.input || "");
+  const name = /^https?:\/\//i.test(input)
+    ? input.replace(/^https?:\/\//i, "")
+    : input.replace(/[\\/]+$/, "").split(/[\\/]/).pop();
+  const slug = name
+    .replace(/[^A-Za-z0-9_-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 40) || "safn";
+  const path = join(base, `altalandi-${stamp}-${slug}.md`);
+  await writeFile(path, batchReportMarkdown(summary), "utf8");
+  return path;
+}