pi-ebb 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rustam Giliaziev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,30 @@
-# Temporary Holding Version
+# pi-ebb
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Spaced repetition in the background of [pi](https://pi.dev). It teaches you words, phrases or any other facts while you work.
+
+```text
+el corazón  │  alt+r Forgot  alt+g Got it  alt+s Skip
+```
+
+## Install
+
+```sh
+pi install npm:pi-ebb
+```
+
+## Use
+
+- `/ebb install <file or URL>` adds a deck file, for example about 2000 words of Castilian Spanish with Russian translations: `/ebb install https://r13v.github.io/ebb/decks/es-ru.json`.
+- `/ebb add <topic>` writes up to 9 new notes with the model of the session. Press `1` to `9` to tick a note, `a` to add the ticked notes, `x` or Escape to cancel.
+- `/ebb decks`, `/ebb stats`, `/ebb pause [1h|30m|2d|off]`.
+
+The card shows above the editor. The shortcuts never take a key the editor types:
+
+- `alt+r`: Forgot, and Next after the answer.
+- `alt+g`: Got it.
+- `alt+s`: Skip.
+- `alt+h`: hide or show the card.
+
+The scheduler is FSRS-6. The data is in `$XDG_DATA_HOME/ebb/` (by default `~/.local/share/ebb/`), shared with the [Claude Code mod](https://github.com/r13v/ebb).
+
+The full guide, the deck file format and the scheduling rules are in the [repository](https://github.com/r13v/ebb#readme).

package/dist/index.js

@@ -0,0 +1,1171 @@
+import { homedir } from "node:os";
+import { matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+// core/decks.ts
+var text = (v) => typeof v === "string" && v.trim() ? v.trim() : void 0;
+/** The deck in a deck file, or why it is not one. */
+var parseDeckFile = (source) => {
+	let v;
+	try {
+		v = JSON.parse(source);
+	} catch {
+		return { error: "the file is not JSON" };
+	}
+	const id = text(v.id)?.toLowerCase();
+	const name = text(v.name);
+	if (!id || !/^[a-z0-9-]+$/.test(id)) return { error: "the deck needs an \"id\" of lowercase letters, digits and hyphens" };
+	if (!name) return { error: "the deck needs a \"name\"" };
+	if (!Array.isArray(v.notes)) return { error: "the deck needs a \"notes\" list" };
+	const notes = [];
+	for (const n of v.notes) {
+		const front = text(n?.front);
+		const back = text(n?.back);
+		if (!front || !back) continue;
+		const tags = Array.isArray(n.tags) ? n.tags.filter((t) => typeof t === "string") : [];
+		notes.push({
+			front,
+			back,
+			hint: text(n.hint),
+			tags
+		});
+	}
+	if (!notes.length) return { error: "the deck has no notes with \"front\" and \"back\"" };
+	const learn = text(v.learn);
+	const native = text(v.native);
+	return {
+		deck: {
+			id,
+			name,
+			learn,
+			native,
+			guidance: text(v.guidance),
+			kinds: learn && native ? ["recognition", "production"] : ["recognition"]
+		},
+		notes
+	};
+};
+// core/generate.ts
+var describeDeck = (deck) => deck.learn && deck.native ? `The deck teaches ${deck.learn} to a ${deck.native} speaker.
+- front: the ${deck.learn} word or phrase.
+- back: a short ${deck.native} translation.
+- hint: optional, one short note in ${deck.native} on a trap. Omit it when there is none.${deck.guidance ? `\n${deck.guidance}` : ""}` : `Deck: ${deck.name}. front: a short question or cue; back: the short answer.${deck.guidance ? `\n${deck.guidance}` : ""}`;
+var generationPrompt = (deck, topic, existing) => ({
+	system: `You write spaced-repetition notes. ${describeDeck(deck)}
+One fact per note. Prefer frequent, useful items. Reply with JSON only, no prose and no code fence:
+{"notes":[{"front":"...","back":"...","hint":"...","tags":["..."]}]}`,
+	prompt: `Topic or list: ${topic}
+Write up to 9 notes. Skip these, the deck has them: ${existing.slice(0, 300).join(", ") || "none"}`
+});
+/** The notes of a model reply, or why there are none. */
+var parseNotes = (text) => {
+	const start = text.indexOf("{");
+	const end = text.lastIndexOf("}");
+	if (start < 0 || end <= start) return { error: "the reply has no JSON" };
+	let value;
+	try {
+		value = JSON.parse(text.slice(start, end + 1));
+	} catch {
+		return { error: "the reply has broken JSON" };
+	}
+	const list = value.notes;
+	if (!Array.isArray(list)) return { error: "the JSON has no notes list" };
+	const notes = [];
+	for (const item of list) {
+		if (typeof item !== "object" || item === null) continue;
+		const { front, back, hint, tags } = item;
+		if (typeof front !== "string" || typeof back !== "string" || !front.trim() || !back.trim()) continue;
+		notes.push({
+			front: front.trim(),
+			back: back.trim(),
+			hint: typeof hint === "string" && hint.trim() ? hint.trim() : void 0,
+			tags: Array.isArray(tags) ? tags.filter((t) => typeof t === "string") : []
+		});
+	}
+	return notes.length ? { notes } : { error: "the reply has no notes" };
+};
+/** Back-translation of a language deck: the model sees only the backs and writes the fronts. */
+var backTranslationPrompt = (deck, notes) => ({
+	system: `Translate each item into ${deck.learn}.${deck.guidance ? ` ${deck.guidance}` : ""} Reply with JSON only: {"fronts":["..."]}, same order and length.`,
+	prompt: JSON.stringify(notes.map((n) => n.back))
+});
+var normalize = (s) => s.toLowerCase().normalize("NFD").replace(/[̀-ͯ]/g, "").replace(/[¿?¡!.,;:()"«»]/g, "").replace(/\s+/g, " ").trim();
+/** Flags the notes whose back-translation does not land on the front; undefined when the reply has no fronts. */
+var flagMismatches = (notes, reply) => {
+	let fronts;
+	try {
+		fronts = JSON.parse(reply.slice(reply.indexOf("{"), reply.lastIndexOf("}") + 1)).fronts;
+	} catch {
+		return;
+	}
+	if (!Array.isArray(fronts)) return void 0;
+	return notes.map((note, i) => {
+		const back = fronts[i];
+		if (typeof back !== "string") return {
+			...note,
+			isChecked: true
+		};
+		const a = normalize(note.front);
+		const b = normalize(back);
+		const words = new Set(a.split(/[ /]/));
+		return a === b || a.includes(b) || b.includes(a) || b.split(/[ /]/).some((w) => w.length > 3 && words.has(w)) ? {
+			...note,
+			isChecked: true
+		} : {
+			...note,
+			isChecked: false,
+			flag: `back-translation: ${back}`
+		};
+	});
+};
+var deckPrompt = (request, recent) => ({
+	system: `A person asks a flashcard app for notes. Decide the deck they need. Reply with JSON only:
+{"id":"short-lowercase-slug","name":"Short deck name","learn":"the language the person learns, or null when the notes are not about a language","native":"the language of the answers, or null"}
+The language of the answers is the language the person writes in, in the request or in their recent messages. When the request is about a language but you cannot tell the person's own language, "native" is null.`,
+	prompt: `Request: ${request}\nRecent messages: ${JSON.stringify(recent.slice(-3))}`
+});
+var parseDeckReply = (text) => {
+	try {
+		const v = JSON.parse(text.slice(text.indexOf("{"), text.lastIndexOf("}") + 1));
+		const id = typeof v.id === "string" ? v.id.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-|-$/g, "") : "";
+		if (!id) return void 0;
+		const text_ = (x) => typeof x === "string" && x.trim() ? x.trim() : null;
+		return {
+			id,
+			name: text_(v.name) ?? id,
+			learn: text_(v.learn),
+			native: text_(v.native)
+		};
+	} catch {
+		return;
+	}
+};
+// core/fsrs.ts
+var DEFAULT_WEIGHTS = [
+	.212,
+	1.2931,
+	2.3065,
+	8.2956,
+	6.4133,
+	.8334,
+	3.0194,
+	.001,
+	1.8722,
+	.1666,
+	.796,
+	1.4835,
+	.0614,
+	.2629,
+	1.6483,
+	.6014,
+	1.8729,
+	.5425,
+	.0912,
+	.0658,
+	.1542
+];
+var MINUTE = 6e4;
+var DAY$1 = 864e5;
+var S_MIN = .001;
+var newSchedule = (now) => ({
+	state: 0,
+	step: null,
+	stability: null,
+	difficulty: null,
+	due: now,
+	lastReview: null
+});
+var clamp = (x, lo, hi) => Math.min(hi, Math.max(lo, x));
+function scheduler(options = {}) {
+	const w = options.weights ?? DEFAULT_WEIGHTS;
+	const retention = options.desiredRetention ?? .9;
+	const learning = options.learningSteps ?? [1 * MINUTE, 10 * MINUTE];
+	const relearning = options.relearningSteps ?? [10 * MINUTE];
+	const maxIvl = options.maximumInterval ?? 36500;
+	const decay = -w[20];
+	const factor = .9 ** (1 / decay) - 1;
+	const retrievability = (s, now) => {
+		if (s.lastReview === null || s.stability === null) return 0;
+		const days = Math.max(0, Math.floor((now - s.lastReview) / DAY$1));
+		return (1 + factor * days / s.stability) ** decay;
+	};
+	const initialStability = (r) => Math.max(w[r - 1], S_MIN);
+	const rawInitialDifficulty = (r) => w[4] - Math.exp(w[5] * (r - 1)) + 1;
+	const initialDifficulty = (r) => clamp(rawInitialDifficulty(r), 1, 10);
+	const nextDifficulty = (d, r) => {
+		const delta = -(w[6] * (r - 3));
+		const damped = d + (10 - d) * delta / 9;
+		return clamp(w[7] * rawInitialDifficulty(4) + (1 - w[7]) * damped, 1, 10);
+	};
+	const shortTermStability = (s, r) => {
+		let inc = Math.exp(w[17] * (r - 3 + w[18])) * s ** -w[19];
+		if (r >= 3) inc = Math.max(inc, 1);
+		return Math.max(s * inc, S_MIN);
+	};
+	const nextStability = (d, s, rr, r) => {
+		if (r === 1) {
+			const longTerm = w[11] * d ** -w[12] * ((s + 1) ** w[13] - 1) * Math.exp((1 - rr) * w[14]);
+			const shortTerm = s / Math.exp(w[17] * w[18]);
+			return Math.max(Math.min(longTerm, shortTerm), S_MIN);
+		}
+		const hard = r === 2 ? w[15] : 1;
+		const easy = r === 4 ? w[16] : 1;
+		const grown = s * (1 + Math.exp(w[8]) * (11 - d) * s ** -w[9] * (Math.exp((1 - rr) * w[10]) - 1) * hard * easy);
+		return Math.max(grown, S_MIN);
+	};
+	const interval = (s) => {
+		return clamp(Math.round(s / factor * (retention ** (1 / decay) - 1)), 1, maxIvl);
+	};
+	const fuzz = (days) => {
+		if (!options.random || days < 2.5) return days;
+		const ranges = [
+			[
+				2.5,
+				7,
+				.15
+			],
+			[
+				7,
+				20,
+				.1
+			],
+			[
+				20,
+				Infinity,
+				.05
+			]
+		];
+		let delta = 1;
+		for (const [lo, hi, f] of ranges) delta += f * Math.max(Math.min(days, hi) - lo, 0);
+		const lo = Math.max(2, Math.round(days - delta));
+		const hi = Math.min(Math.round(days + delta), maxIvl);
+		return Math.min(Math.round(options.random() * (hi - lo + 1) + lo), maxIvl);
+	};
+	const stepDelay = (steps, step, r) => {
+		if (r === 2 && step === 0) return steps.length === 1 ? steps[0] * 1.5 : (steps[0] + steps[1]) / 2;
+		return steps[step];
+	};
+	/** The schedule after grading `s` with `r` at `now`. */
+	const review = (s, r, now) => {
+		let stability;
+		let difficulty;
+		if (s.stability === null || s.difficulty === null) {
+			stability = initialStability(r);
+			difficulty = initialDifficulty(r);
+		} else {
+			stability = s.lastReview !== null && now - s.lastReview < DAY$1 ? shortTermStability(s.stability, r) : nextStability(s.difficulty, s.stability, retrievability(s, now), r);
+			difficulty = nextDifficulty(s.difficulty, r);
+		}
+		let state = s.state === 0 ? 1 : s.state;
+		let step = s.state === 0 ? 0 : s.step;
+		let delay;
+		const graduate = () => {
+			state = 2;
+			step = null;
+			return interval(stability) * DAY$1;
+		};
+		if (state === 2) {
+			if (r === 1 && relearning.length > 0) {
+				state = 3;
+				step = 0;
+				delay = relearning[0];
+			} else delay = graduate();
+		} else {
+			const steps = state === 1 ? learning : relearning;
+			const at = step ?? 0;
+			if (steps.length === 0 || at >= steps.length && r > 1) delay = graduate();
+			else if (r === 1) {
+				step = 0;
+				delay = steps[0];
+			} else if (r === 2) delay = stepDelay(steps, at, r);
+			else if (r === 3) {
+				if (at + 1 >= steps.length) delay = graduate();
+				else {
+					step = at + 1;
+					delay = steps[at + 1];
+				}
+			} else delay = graduate();
+		}
+		if (state === 2 && options.random) delay = fuzz(delay / DAY$1) * DAY$1;
+		return {
+			state,
+			step,
+			stability,
+			difficulty,
+			due: now + delay,
+			lastReview: now
+		};
+	};
+	return { review };
+}
+// core/model.ts
+var DAY = 864e5;
+var emptyData = () => ({
+	version: 1,
+	decks: {},
+	notes: {},
+	cards: {},
+	meta: {}
+});
+/** New recognition cards a deck brings each day, as in Anki. */
+var NEW_PER_DAY = 20;
+var OLD_NEW_PER_DAY = 10;
+/**
+* Reads data that earlier builds wrote. The first build kept one daily counter for all decks;
+* it was the Spanish deck's. A deck still on the old default of 10 new cards a day gets the new one.
+*/
+var upgrade = (data) => {
+	for (const deck of Object.values(data.decks)) if (deck.newPerDay === OLD_NEW_PER_DAY) deck.newPerDay = NEW_PER_DAY;
+	const old = data.meta;
+	if (old.newDay !== void 0) {
+		data.meta.newByDeck ??= { es: {
+			day: old.newDay,
+			count: old.newToday ?? 0
+		} };
+		delete old.newDay;
+		delete old.newToday;
+	}
+	return data;
+};
+/** FNV-1a, hex: a stable id for a note from its deck and front. */
+var noteId = (deck, front) => {
+	let h = 2166136261;
+	for (const ch of `${deck}\u0000${front.trim().toLowerCase()}`) {
+		h ^= ch.codePointAt(0);
+		h = Math.imul(h, 16777619) >>> 0;
+	}
+	return h.toString(16).padStart(8, "0");
+};
+var face = (data, card) => {
+	const note = data.notes[card.note];
+	if (!note) return void 0;
+	return card.kind === "recognition" ? {
+		card,
+		note,
+		ask: note.front,
+		answer: note.back,
+		hint: note.hint
+	} : {
+		card,
+		note,
+		ask: note.back,
+		answer: note.front,
+		hint: note.hint
+	};
+};
+var ensureDeck = (data, deck) => {
+	data.decks[deck.id] ??= {
+		newPerDay: NEW_PER_DAY,
+		kinds: ["recognition", "production"],
+		productionUnlockDays: 21,
+		...deck
+	};
+	return data.decks[deck.id];
+};
+/**
+* Adds notes not yet in the deck, each with its recognition card. Returns how many were new.
+* With `merge`, a note whose front exists already adds its meanings, hint and tags to that note
+* (one word in two word lists, such as `mejor` the adjective and the adverb).
+*/
+var addNotes = (data, deckId, notes, source, now, merge = false) => {
+	const deck = data.decks[deckId];
+	if (!deck) throw new Error(`no deck ${deckId}`);
+	let order = Object.values(data.notes).filter((n) => n.deck === deckId).length;
+	let added = 0;
+	for (const input of notes) {
+		const front = input.front.trim();
+		const back = input.back.trim();
+		if (!front || !back) continue;
+		const key = front.toLowerCase();
+		let id = noteId(deckId, front);
+		for (let n = 1; data.notes[id] && data.notes[id].front.toLowerCase() !== key; n++) id = `${noteId(deckId, front)}-${n}`;
+		const existing = data.notes[id];
+		if (existing) {
+			if (merge) {
+				const backs = existing.back.split("; ");
+				for (const part of back.split("; ")) if (!backs.includes(part)) backs.push(part);
+				existing.back = backs.join("; ");
+				existing.hint ??= input.hint?.trim() || void 0;
+				existing.tags = [.../* @__PURE__ */ new Set([...existing.tags, ...input.tags ?? []])];
+			}
+			continue;
+		}
+		data.notes[id] = {
+			id,
+			deck: deckId,
+			front,
+			back,
+			hint: input.hint?.trim() || void 0,
+			tags: input.tags ?? [],
+			order: order++,
+			source,
+			createdAt: now
+		};
+		const first = deck.kinds.includes("recognition") ? "recognition" : deck.kinds[0];
+		data.cards[`${id}:${first[0]}`] = {
+			...newSchedule(now),
+			id: `${id}:${first[0]}`,
+			note: id,
+			kind: first,
+			reps: 0,
+			lapses: 0
+		};
+		added++;
+	}
+	return added;
+};
+var isNew = (c) => c.state === 0;
+var localDay = (now) => new Date(now).toDateString();
+var newLeftToday = (data, deck, now) => {
+	const today = data.meta.newByDeck?.[deck.id];
+	return today?.day === localDay(now) ? Math.max(0, deck.newPerDay - today.count) : deck.newPerDay;
+};
+var counts = (data, now) => {
+	let due = 0;
+	let fresh = 0;
+	for (const c of Object.values(data.cards)) if (isNew(c)) fresh++;
+	else if (c.due <= now) due++;
+	return {
+		due,
+		new: fresh
+	};
+};
+var byOrder = (data) => (a, b) => (data.notes[a.note]?.order ?? 0) - (data.notes[b.note]?.order ?? 0);
+/**
+* The next card for the band, or none only when every card is skipped.
+* By schedule first: due cards, new recognition cards within the daily limit, new production
+* cards. Then ahead of schedule, so the band never runs dry: new cards past the limit, in deck
+* order, then the card that comes due soonest. A learning card waits for its step (1 or 10
+* minutes) like any other: shown early, it would come straight back after its grade.
+* A production card is of a word the person knows already, so it takes none of the daily limit:
+* otherwise a mature deck would fill the limit with them and stop new words.
+* With `isNewTurn`, a new card within the limit goes before the due ones: the band alternates
+* them, as Anki mixes new cards with reviews, so a run of due cards never stops new words.
+*/
+var nextCard = (data, now, skip = /* @__PURE__ */ new Set(), isNewTurn = false) => {
+	const cards = Object.values(data.cards).filter((c) => !skip.has(c.id) && data.notes[c.note]);
+	const fresh = cards.filter(isNew).sort(byOrder(data));
+	const freshToday = fresh.find((c) => c.kind === "recognition" && newLeftToday(data, data.decks[data.notes[c.note].deck], now) > 0);
+	if (isNewTurn && freshToday) return freshToday;
+	const due = cards.filter((c) => !isNew(c) && c.due <= now).sort((a, b) => a.due - b.due);
+	if (due[0]) return due[0];
+	if (freshToday) return freshToday;
+	const production = fresh.find((c) => c.kind === "production");
+	if (production) return production;
+	const soonest = cards.filter((c) => !isNew(c)).sort((a, b) => a.due - b.due);
+	return fresh[0] ?? soonest[0];
+};
+/** Grades a card: the new schedule, its log row, and a production card if this unlocked one. */
+var grade = (data, cardId, rating, now, random, durationMs) => {
+	const before = data.cards[cardId];
+	if (!before) throw new Error(`no card ${cardId}`);
+	const note = data.notes[before.note];
+	const deck = data.decks[note.deck];
+	const next = scheduler({ random }).review(before, rating, now);
+	const card = {
+		...before,
+		...next,
+		reps: before.reps + 1,
+		lapses: before.lapses + (rating === 1 && before.state === 2 ? 1 : 0)
+	};
+	data.cards[cardId] = card;
+	if (before.state === 0 && before.kind === "recognition") {
+		const day = localDay(now);
+		data.meta.newByDeck ??= {};
+		const byDeck = data.meta.newByDeck;
+		const today = byDeck[deck.id];
+		byDeck[deck.id] = {
+			day,
+			count: today?.day === day ? today.count + 1 : 1
+		};
+	}
+	const log = {
+		ts: now,
+		card: cardId,
+		rating,
+		state: before.state,
+		stability: before.stability,
+		difficulty: before.difficulty,
+		scheduledMs: card.due - now,
+		durationMs
+	};
+	let unlocked;
+	const prodId = `${note.id}:p`;
+	if (card.kind === "recognition" && deck.kinds.includes("production") && !data.cards[prodId] && (card.stability ?? 0) >= deck.productionUnlockDays) {
+		unlocked = {
+			...newSchedule(now),
+			id: prodId,
+			note: note.id,
+			kind: "production",
+			reps: 0,
+			lapses: 0
+		};
+		data.cards[prodId] = unlocked;
+	}
+	return {
+		card,
+		log,
+		unlocked
+	};
+};
+/** `1h`, `30m`, `2d` → ms; undefined when it does not parse. */
+var parseDuration = (text) => {
+	const m = /^(\d+(?:\.\d+)?)\s*(m|min|h|d)$/i.exec(text.trim());
+	if (!m) return void 0;
+	const unit = {
+		m: 6e4,
+		min: 6e4,
+		h: 36e5,
+		d: DAY
+	}[m[2].toLowerCase()];
+	return Number(m[1]) * unit;
+};
+var monthKey = (now) => {
+	const d = new Date(now);
+	return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}`;
+};
+// core/ebb.ts
+/** Where both hosts keep the data: `$XDG_DATA_HOME/ebb`, by default `~/.local/share/ebb`. */
+var dataDir = (home, xdgDataHome) => `${xdgDataHome || `${home}/.local/share`}/ebb`;
+var HELP = `/ebb decks — your decks
+/ebb install <file or URL> — add a deck file
+/ebb add [@deck] <topic or word list> — write new notes with the model; a new @deck is made on first use
+/ebb pause [1h|30m|2d|off] — no card above the prompt for a while
+/ebb stats — notes, due cards and new cards`;
+var LOCK_STALE_MS = 1e4;
+var RECENT_PROMPTS = 3;
+/** The deck a new deck becomes: a language deck asks both ways, a deck of facts one way. */
+var deckFrom = (d) => d.learn ? {
+	...d,
+	kinds: ["recognition", "production"]
+} : {
+	id: d.id,
+	name: d.name,
+	kinds: ["recognition"]
+};
+/** One session of a host: its caches, its own log file, the card in its band and the cards it skipped. */
+var createSession = () => {
+	const sessionId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+	const dataPath = (host) => `${host.dir}/data.json`;
+	let cache;
+	/** The data as on disk, read again only when another session changed the file. */
+	const load = async (host) => {
+		const path = dataPath(host);
+		if (!await host.exists(path)) {
+			cache = {
+				data: emptyData(),
+				mtimeMs: 0
+			};
+			return cache.data;
+		}
+		const mtimeMs = await host.mtimeMs(path);
+		if (cache && cache.mtimeMs === mtimeMs) return cache.data;
+		const data = upgrade(JSON.parse(await host.read(path)));
+		cache = {
+			data,
+			mtimeMs
+		};
+		return data;
+	};
+	/**
+	* Runs `work` under the lock of the data directory, so two sessions never lose each other's writes.
+	* `mkdir` takes the lock atomically and an owner file inside names who holds it.
+	* A lock older than 10 s is taken as left by a dead session: it is renamed away first,
+	* so only one waiter removes it.
+	*/
+	const withLock = async (host, work) => {
+		const lock = `${host.dir}/lock`;
+		const token = `${sessionId}-${Math.random().toString(36).slice(2, 8)}`;
+		await host.mkdirp(host.dir);
+		for (let waited = 0;; waited += 100) {
+			if (await host.mkdir(lock)) break;
+			const heldSince = await host.mtimeMs(lock).catch(() => void 0);
+			if (heldSince !== void 0 && Date.now() - heldSince > LOCK_STALE_MS) {
+				const aside = `${lock}.stale-${token}`;
+				if (await host.rename(lock, aside)) await host.remove(aside);
+				continue;
+			}
+			if (waited > 12e3) throw new Error("данные заняты другой сессией, попробуйте ещё раз");
+			await host.sleep(100);
+		}
+		await host.write(`${lock}/owner`, token);
+		try {
+			return await work();
+		} finally {
+			if (await host.read(`${lock}/owner`).catch(() => void 0) === token) await host.remove(lock);
+		}
+	};
+	/** Replaces a file by an atomic rename, so a reader never sees half of it. */
+	const replaceFile = async (host, path, text) => {
+		await host.write(`${path}.tmp`, text);
+		if (!await host.rename(`${path}.tmp`, path)) throw new Error(`не удалось сохранить ${path}`);
+	};
+	/** Changes `data.json` under the lock, on a copy read again inside it. The only writer of the file. */
+	const mutate = (host, change) => withLock(host, async () => {
+		try {
+			cache = void 0;
+			const data = await load(host);
+			const result = change(data);
+			const path = dataPath(host);
+			await replaceFile(host, path, JSON.stringify(data));
+			cache = {
+				data,
+				mtimeMs: await host.mtimeMs(path)
+			};
+			return result;
+		} catch (error) {
+			cache = void 0;
+			throw error;
+		}
+	});
+	let log;
+	let logWrite = Promise.resolve();
+	/** Appends a review to this session's own log for the month. */
+	const appendLog = async (host, review) => {
+		const path = `${host.dir}/log/${monthKey(review.ts)}/${sessionId}.json`;
+		if (log?.key !== path) log = {
+			key: path,
+			value: { reviews: [] }
+		};
+		log.value.reviews.push(review);
+		const text = JSON.stringify(log.value);
+		logWrite = logWrite.catch(() => void 0).then(() => host.write(path, text));
+		await logWrite;
+	};
+	let band = {
+		cardId: null,
+		isRevealed: false,
+		shownAt: 0
+	};
+	const setBand = async (host, next) => {
+		band = next;
+		await host.showBand(band);
+	};
+	const skipped = /* @__PURE__ */ new Set();
+	let chosenWith = false;
+	let wasNew = false;
+	/**
+	* Puts the next card in the band, with its answer hidden. `previous`, the card just graded or
+	* skipped, never comes straight back while another card is left. `isRepick` chooses again for
+	* the same turn, so a card that came due can take the band's place without moving the turns.
+	*/
+	const showNextCard = async (host, previous, isRepick = false) => {
+		try {
+			const data = await load(host);
+			const now = Date.now();
+			const avoid = previous ? [previous] : [];
+			const isNewTurn = isRepick ? chosenWith : !wasNew;
+			let card = nextCard(data, now, /* @__PURE__ */ new Set([...skipped, ...avoid]), isNewTurn);
+			if (!card) {
+				skipped.clear();
+				card = nextCard(data, now, new Set(avoid), isNewTurn) ?? nextCard(data, now);
+			}
+			chosenWith = isNewTurn;
+			wasNew = card?.state === 0;
+			await setBand(host, {
+				cardId: card?.id ?? null,
+				isRevealed: false,
+				shownAt: now
+			});
+			return;
+		} catch (error) {
+			await setBand(host, {
+				cardId: null,
+				isRevealed: false,
+				shownAt: 0
+			});
+			return String(error);
+		}
+	};
+	const skip = async (host) => {
+		if (band.cardId) skipped.add(band.cardId);
+		await showNextCard(host, band.cardId ?? void 0);
+	};
+	/** After Forgot showed the answer: the next card. */
+	const next = (host) => showNextCard(host, band.cardId ?? void 0);
+	let isGrading = false;
+	/** Grades the card in the band; a forgotten card shows its answer until `next`. Throws when the grade was not saved. */
+	const gradeCard = async (host, rating) => {
+		const graded = band;
+		if (isGrading || !graded.cardId || graded.isRevealed) return;
+		isGrading = true;
+		const cardId = graded.cardId;
+		try {
+			const result = await mutate(host, (data) => grade(data, cardId, rating, Date.now(), Math.random, Date.now() - graded.shownAt));
+			await appendLog(host, result.log);
+			skipped.delete(cardId);
+			if (rating === 1) await setBand(host, {
+				...band,
+				isRevealed: true
+			});
+			else await showNextCard(host, cardId);
+		} finally {
+			isGrading = false;
+		}
+	};
+	/** At the end of a turn a card may have come due; an open answer stays as it is. */
+	const endTurn = async (host) => {
+		if (!band.isRevealed) await showNextCard(host, void 0, true);
+	};
+	/** What the band draws now; `shown` is the band as the host keeps it. A reader on every render: it never throws. */
+	const bandView = async (host, shown = band) => {
+		let data;
+		try {
+			data = await load(host);
+		} catch (error) {
+			return {
+				kind: "error",
+				error: String(error)
+			};
+		}
+		if (!Object.keys(data.decks).length) return { kind: "no-deck" };
+		const card = shown.cardId ? data.cards[shown.cardId] : void 0;
+		const f = card && face(data, card);
+		if ((data.meta.pausedUntil ?? 0) > Date.now() || !f) return { kind: "none" };
+		return {
+			kind: "card",
+			face: f,
+			isRevealed: shown.isRevealed
+		};
+	};
+	/**
+	* `/ebb install <path or URL>`: adds a deck file. Installing it again adds the notes that are
+	* new and the meanings that are new; cards keep their schedule.
+	*/
+	const installDeck = async (host, where) => {
+		if (!where) return "Name a deck file or URL: /ebb install ~/decks/spanish.json";
+		let source;
+		if (/^https?:\/\//.test(where)) {
+			const r = await host.fetch(where);
+			if (!r.ok) return `Could not download the deck: HTTP ${r.status}`;
+			source = r.text;
+		} else {
+			const path = where.startsWith("~/") ? `${host.home}${where.slice(1)}` : where;
+			if (!await host.exists(path)) return `No file ${path}`;
+			source = await host.read(path);
+		}
+		const file = parseDeckFile(source);
+		if ("error" in file) return `Not a deck: ${file.error}`;
+		const added = await mutate(host, (d) => {
+			ensureDeck(d, file.deck);
+			return addNotes(d, file.deck.id, file.notes, `install: ${where}`, Date.now(), true);
+		});
+		await showNextCard(host);
+		return `Installed ${file.deck.name}: ${added} new notes. Its cards show above the prompt.`;
+	};
+	const listDecks = async (host) => {
+		const data = await load(host);
+		const now = Date.now();
+		const rows = Object.values(data.decks).map((d) => {
+			const cards = Object.values(data.cards).filter((c) => data.notes[c.note]?.deck === d.id);
+			const due = cards.filter((c) => c.state !== 0 && c.due <= now).length;
+			const fresh = cards.filter((c) => c.state === 0).length;
+			return `${d.id} — ${d.name}: ${cards.length} cards, ${due} due, ${fresh} new`;
+		});
+		return [
+			...rows.length ? rows : ["No deck yet."],
+			"",
+			"Make one: /ebb add <topic>. Install one: /ebb install <file or URL>."
+		].join("\n");
+	};
+	const stats = async (host) => {
+		const data = await load(host);
+		const c = counts(data, Date.now());
+		const paused = (data.meta.pausedUntil ?? 0) > Date.now() ? " · paused" : "";
+		return `Notes: ${Object.keys(data.notes).length} · due: ${c.due} · new: ${c.new}${paused}`;
+	};
+	const pause = async (host, tail) => {
+		if (tail === "off") {
+			await mutate(host, (data) => void delete data.meta.pausedUntil);
+			await host.showBand(band);
+			return "Cards are back above the prompt.";
+		}
+		const ms = tail ? parseDuration(tail) : 36e5;
+		if (!ms) return "Use /ebb pause 1h, 30m, 2d or off";
+		const until = Date.now() + ms;
+		await mutate(host, (data) => {
+			data.meta.pausedUntil = until;
+		});
+		await host.showBand(band);
+		return `Paused until ${new Date(until).toLocaleTimeString(void 0, {
+			hour: "2-digit",
+			minute: "2-digit"
+		})}.`;
+	};
+	/** `/ebb <args>`: the text to show. `add` belongs to the host, which draws its list. */
+	const runCommand = async (host, args, add) => {
+		const [sub = "", ...rest] = args.trim().split(/\s+/);
+		const tail = rest.join(" ");
+		switch (sub) {
+			case "decks": return listDecks(host);
+			case "install": return installDeck(host, tail);
+			case "add": return tail ? add(tail) : "Name a topic: /ebb add ordering at a bar";
+			case "pause": return pause(host, tail);
+			case "stats": return stats(host);
+			default: return `${await stats(host)}\n\n${HELP}`;
+		}
+	};
+	const recentPrompts = [];
+	const notePrompt = (text) => {
+		if (text.trimStart().startsWith("/")) return;
+		recentPrompts.push(text.slice(0, 300));
+		if (recentPrompts.length > RECENT_PROMPTS) recentPrompts.shift();
+	};
+	/**
+	* The start of `/ebb add [@deck] <topic>`: the view to show and the deck, when it exists. Text
+	* when the request cannot go on. A new deck is saved only with its first notes (`commitAdd`).
+	*/
+	const planAdd = async (host, args) => {
+		const match = /^@([\w-]+)\s+(.+)$/u.exec(args);
+		const named = match?.[1];
+		const topic = match ? match[2] : args;
+		const data = await load(host);
+		const decks = Object.values(data.decks);
+		if (!named && decks.length > 1) return { text: `Name the deck: /ebb add @<deck> ${topic}. Decks: ${decks.map((d) => d.id).join(", ")}.` };
+		const onlyDeck = decks.length === 1 ? decks[0] : void 0;
+		const deck = named ? data.decks[named] : onlyDeck;
+		return {
+			view: {
+				deck: deck?.id ?? named ?? "",
+				topic,
+				candidates: [],
+				status: "Reading the request…"
+			},
+			deck,
+			named
+		};
+	};
+	/** A new deck from the request and the person's recent prompts; `native` stays empty when unclear. */
+	const askDeck = async (host, args, named) => {
+		const r = await host.complete({
+			...deckPrompt(args, recentPrompts),
+			maxTokens: 300,
+			timeoutMs: 6e4
+		});
+		const reply = "text" in r ? parseDeckReply(r.text) : void 0;
+		return {
+			id: named ?? reply?.id ?? "notes",
+			name: reply?.name ?? named ?? "Notes",
+			learn: reply?.learn ?? void 0,
+			native: reply?.native ?? void 0
+		};
+	};
+	/**
+	* Up to 9 new notes on the topic. In a language deck a second call translates them back; a note
+	* that does not match is flagged and unticked. Notes the deck has are marked and unticked.
+	*/
+	const draftNotes = async (host, deck, topic, onStatus) => {
+		const data = await load(host);
+		await onStatus("Writing notes…");
+		const existing = Object.values(data.notes).filter((n) => n.deck === deck.id).map((n) => n.front);
+		const asDeck = {
+			...deckFrom(deck),
+			...deck
+		};
+		const made = await host.complete({
+			...generationPrompt(asDeck, topic, existing),
+			maxTokens: 3e3,
+			timeoutMs: 12e4
+		});
+		if ("error" in made) return {
+			candidates: [],
+			status: `The model did not answer: ${made.error}`
+		};
+		const parsed = parseNotes(made.text);
+		if ("error" in parsed) return {
+			candidates: [],
+			status: parsed.error
+		};
+		const notes = parsed.notes.slice(0, 9);
+		const known = new Set(existing.map((f) => f.toLowerCase()));
+		let candidates = notes.map((n) => ({
+			...n,
+			isChecked: true
+		}));
+		let status;
+		if (deck.learn) {
+			await onStatus("Checking by back-translation…");
+			const checked = await host.complete({
+				...backTranslationPrompt(asDeck, notes),
+				maxTokens: 1500,
+				timeoutMs: 6e4
+			});
+			const flagged = "text" in checked ? flagMismatches(notes, checked.text) : void 0;
+			candidates = flagged ?? notes.map((n) => ({
+				...n,
+				isChecked: false
+			}));
+			if (!flagged) status = "The back-translation failed: check the notes yourself and tick the good ones";
+		}
+		candidates = candidates.map((c) => known.has(c.front.toLowerCase()) ? {
+			...c,
+			isDuplicate: true,
+			isChecked: false
+		} : c);
+		return {
+			candidates,
+			status
+		};
+	};
+	/** Adds the ticked notes, and the new deck with them; the band then takes a card. Returns how many were added. */
+	const commitAdd = async (host, view) => {
+		const chosen = view.candidates.filter((c) => c.isChecked && !c.isDuplicate);
+		const added = await mutate(host, (data) => {
+			if (view.newDeck) ensureDeck(data, deckFrom(view.newDeck));
+			return addNotes(data, view.deck, chosen, `ebb add: ${view.topic}`, Date.now());
+		});
+		await showNextCard(host);
+		return added;
+	};
+	return {
+		showNextCard,
+		skip,
+		next,
+		gradeCard,
+		endTurn,
+		bandView,
+		runCommand,
+		notePrompt,
+		planAdd,
+		askDeck,
+		draftNotes,
+		commitAdd
+	};
+};
+/** Ticks or unticks the candidate at `index`; a note the deck has stays unticked. */
+var toggleCandidate = (view, index) => ({
+	...view,
+	candidates: view.candidates.map((c, j) => j === index && !c.isDuplicate ? {
+		...c,
+		isChecked: !c.isChecked
+	} : c)
+});
+/** The mark of a candidate in the list of `/ebb add`. */
+var checkbox = (c) => {
+	if (c.isDuplicate) return "[have]";
+	return c.isChecked ? "[x]" : "[ ]";
+};
+/** How many notes `commitAdd` would add. */
+var tickedCount = (view) => view.candidates.filter((c) => c.isChecked && !c.isDuplicate).length;
+/** A candidate as one line of the list. */
+var candidateLine = (c) => `${checkbox(c)} ${c.front} — ${c.back}${c.hint ? ` (${c.hint})` : ""}${c.flag ? ` ⚠ ${c.flag}` : ""}`;
+// pi/host.ts
+var isOk = (work) => work.then(() => true, () => false);
+var fileHost = (home, dir) => ({
+	home,
+	dir,
+	exists: (path) => isOk(stat(path)),
+	read: (path) => readFile(path, "utf8"),
+	write: async (path, text) => {
+		await mkdir(dirname(path), { recursive: true });
+		await writeFile(path, text);
+	},
+	mtimeMs: async (path) => (await stat(path)).mtimeMs,
+	mkdir: (path) => isOk(mkdir(path)),
+	mkdirp: async (path) => void await mkdir(path, { recursive: true }),
+	rename: (from, to) => isOk(rename(from, to)),
+	remove: (path) => rm(path, {
+		recursive: true,
+		force: true
+	}),
+	sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+	fetch: async (url) => {
+		const r = await fetch(url);
+		return {
+			ok: r.ok,
+			status: r.status,
+			text: await r.text()
+		};
+	}
+});
+// pi/index.ts
+var WIDGET = "ebb";
+var KEYS = {
+	forgot: "alt+r",
+	got: "alt+g",
+	skip: "alt+s",
+	toggle: "alt+h"
+};
+var files = fileHost(homedir(), dataDir(homedir(), process.env.XDG_DATA_HOME));
+var SETTINGS = `${files.dir}/pi.json`;
+var textOf = (content) => content.filter((c) => c.type === "text").map((c) => c.text).join("");
+/** The lines of the band; none while it is hidden, paused or without a card. */
+var bandLines = (v, theme) => {
+	if (v.kind === "error") return [theme.fg("error", `ebb: cannot read the data: ${v.error}`)];
+	if (v.kind === "no-deck") return [theme.fg("dim", "ebb: /ebb add <topic> or /ebb install <file or URL> to get cards")];
+	if (v.kind === "none") return void 0;
+	const f = v.face;
+	const bar = theme.fg("dim", "│");
+	const key = (keys, label) => `${theme.fg("accent", keys)} ${label}`;
+	if (v.isRevealed) {
+		const hint = f.hint ? theme.fg("dim", ` (${f.hint})`) : "";
+		return [`${theme.bold(f.ask)} — ${f.answer}${hint}  ${bar}  ${key(KEYS.forgot, "Next")}`];
+	}
+	const keys = [
+		key(KEYS.forgot, "Forgot"),
+		key(KEYS.got, "Got it"),
+		key(KEYS.skip, "Skip")
+	].join("  ");
+	return [`${theme.bold(f.ask)}  ${bar}  ${keys}`];
+};
+function ebb(pi) {
+	const session = createSession();
+	let ctx;
+	let isHidden = false;
+	const draw = async () => {
+		if (!ctx?.hasUI) return;
+		const ui = ctx.ui;
+		const lines = isHidden ? void 0 : bandLines(await session.bandView(host), ui.theme);
+		ui.setWidget(WIDGET, lines);
+	};
+	const host = {
+		...files,
+		complete: async ({ system, prompt, maxTokens, timeoutMs }) => {
+			const model = ctx?.model;
+			if (!ctx || !model) return { error: "no model is selected" };
+			const reply = await ctx.modelRegistry.complete(model, {
+				systemPrompt: system,
+				messages: [{
+					role: "user",
+					content: [{
+						type: "text",
+						text: prompt
+					}],
+					timestamp: Date.now()
+				}]
+			}, {
+				maxTokens,
+				signal: AbortSignal.timeout(timeoutMs)
+			});
+			if (reply.stopReason === "error" || reply.stopReason === "aborted") return { error: reply.errorMessage ?? reply.stopReason };
+			return { text: textOf(reply.content) };
+		},
+		showBand: draw
+	};
+	const notify = (text, level = "info") => ctx?.ui.notify(text, level);
+	/** Runs a shortcut; a failure says what went wrong. */
+	const act = (work) => async (shortcutCtx) => {
+		ctx = shortcutCtx;
+		try {
+			await work();
+		} catch (error) {
+			notify(`ebb: ${String(error)}`, "error");
+		}
+	};
+	/** A band shortcut acts only on a card the band shows. */
+	const onCard = (work) => act(async () => {
+		const v = await session.bandView(host);
+		if (!isHidden && v.kind === "card") await work(v.isRevealed);
+	});
+	const showNextCard = async () => {
+		const error = await session.showNextCard(host);
+		if (error) notify(`ebb: ${error}`, "error");
+	};
+	/** `/ebb add`: the deck, its languages, then the list of new notes to tick. */
+	const add = async (command, args) => {
+		if (command.mode !== "tui") return "/ebb add needs the interactive mode";
+		const plan = await session.planAdd(host, args);
+		if ("text" in plan) return plan.text;
+		let view = plan.view;
+		let deck = plan.deck;
+		if (!deck) {
+			command.ui.setStatus(WIDGET, "ebb: reading the request…");
+			const newDeck = await session.askDeck(host, args, plan.named).finally(() => command.ui.setStatus(WIDGET, void 0));
+			if (newDeck.learn && !newDeck.native) {
+				const native = (await command.ui.input(`Translate ${newDeck.learn} into which language?`, "for example: English"))?.trim();
+				if (!native) return "Nothing added.";
+				newDeck.native = native;
+			}
+			view = {
+				...view,
+				deck: newDeck.id,
+				newDeck
+			};
+			deck = newDeck;
+		}
+		const drafted = deck;
+		const chosen = await command.ui.custom((tui, theme, _keys, done) => {
+			let current = view;
+			const redraw = async (change) => {
+				current = {
+					...current,
+					...change
+				};
+				tui.requestRender();
+			};
+			session.draftNotes(host, drafted, current.topic, (status) => redraw({ status })).then(redraw, (error) => redraw({ status: `Error: ${String(error)}` }));
+			return {
+				render: (width) => {
+					const rows = current.candidates.map((c, i) => `${theme.fg("accent", String(i + 1))} ${candidateLine(c)}`);
+					const actions = current.candidates.length ? `${theme.fg("accent", "a")} add ticked (${tickedCount(current)})  ${theme.fg("accent", "x")} cancel` : `${theme.fg("accent", "x")} cancel`;
+					return [
+						theme.bold(`New notes: ${current.topic}`),
+						...current.status ? [theme.fg("dim", current.status)] : [],
+						...rows,
+						actions
+					].map((line) => truncateToWidth(line, width));
+				},
+				handleInput: (data) => {
+					const digit = Number(data);
+					if (Number.isInteger(digit) && digit >= 1 && digit <= current.candidates.length) {
+						current = toggleCandidate(current, digit - 1);
+						tui.requestRender();
+						return;
+					}
+					if (data === "a" && current.candidates.length) done(current);
+					if (data === "x" || matchesKey(data, "escape")) done(void 0);
+				},
+				invalidate: () => void 0
+			};
+		});
+		if (!chosen) return "Nothing added.";
+		return `ebb: notes added: ${await session.commitAdd(host, chosen)}`;
+	};
+	pi.on("session_start", async (_event, startCtx) => {
+		ctx = startCtx;
+		const settings = await files.read(SETTINGS).catch(() => "{}");
+		try {
+			isHidden = JSON.parse(settings).hidden === true;
+		} catch {
+			isHidden = false;
+		}
+		await showNextCard();
+	});
+	pi.on("input", (event, inputCtx) => {
+		ctx = inputCtx;
+		if (event.source === "interactive") session.notePrompt(event.text);
+	});
+	pi.on("agent_end", async (_event, endCtx) => {
+		ctx = endCtx;
+		await session.endTurn(host);
+	});
+	pi.registerCommand("ebb", {
+		description: "Spaced repetition above the editor: add, install, decks, pause, stats",
+		handler: async (args, command) => {
+			ctx = command;
+			const text = await session.runCommand(host, args, (tail) => add(command, tail)).catch((error) => `ebb: ${String(error)}`);
+			notify(text);
+		}
+	});
+	pi.registerShortcut(KEYS.forgot, {
+		description: "ebb: Forgot, or Next after the answer",
+		handler: onCard((isRevealed) => isRevealed ? session.next(host) : session.gradeCard(host, 1))
+	});
+	pi.registerShortcut(KEYS.got, {
+		description: "ebb: Got it",
+		handler: onCard(async (isRevealed) => !isRevealed && session.gradeCard(host, 3))
+	});
+	pi.registerShortcut(KEYS.skip, {
+		description: "ebb: skip the card",
+		handler: onCard(async (isRevealed) => !isRevealed && session.skip(host))
+	});
+	pi.registerShortcut(KEYS.toggle, {
+		description: "ebb: hide or show the card above the editor",
+		handler: act(async () => {
+			isHidden = !isHidden;
+			await files.write(SETTINGS, JSON.stringify({ hidden: isHidden }));
+			await draw();
+		})
+	});
+}
+export { ebb as default };

package/package.json

@@ -1,6 +1,38 @@
 {
   "name": "pi-ebb",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Spaced repetition in the background of pi: a card above the editor, graded with a shortcut",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/r13v/ebb.git",
+    "directory": "pi"
+  },
+  "bugs": {
+    "url": "https://github.com/r13v/ebb/issues"
+  },
+  "homepage": "https://github.com/r13v/ebb/tree/main/pi#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "pi-package",
+    "spaced-repetition",
+    "flashcards",
+    "fsrs"
+  ],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./dist/index.js"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-tui": "*"
+  }
+}