@teammates/cli 0.1.0 → 0.2.0

package/dist/compact.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Episodic memory compaction.
+ *
+ * Compresses daily logs into weekly summaries, and old weekly summaries
+ * into monthly summaries. During weekly compaction, durable knowledge
+ * is extracted into typed memory files.
+ *
+ * Compaction pipeline:
+ *   daily logs (7 days) → weekly summary (kept 52 weeks)
+ *   weekly summaries (>52 weeks) → monthly summary (kept permanently)
+ */
+export interface CompactionResult {
+    teammate: string;
+    weekliesCreated: string[];
+    monthliesCreated: string[];
+    dailiesRemoved: string[];
+    weekliesRemoved: string[];
+}
+/**
+ * Compact daily logs into weekly summaries for a single teammate.
+ * Only compacts complete weeks (not the current week).
+ */
+export declare function compactDailies(teammateDir: string): Promise<{
+    created: string[];
+    removed: string[];
+}>;
+/**
+ * Compact weekly summaries older than 52 weeks into monthly summaries.
+ */
+export declare function compactWeeklies(teammateDir: string): Promise<{
+    created: string[];
+    removed: string[];
+}>;
+/**
+ * Run full episodic compaction for a teammate:
+ * 1. Compact completed weeks' dailies → weekly summaries
+ * 2. Compact weeklies older than 52 weeks → monthly summaries
+ */
+export declare function compactEpisodic(teammateDir: string, teammateName: string): Promise<CompactionResult>;

package/dist/compact.js

@@ -0,0 +1,269 @@
+/**
+ * Episodic memory compaction.
+ *
+ * Compresses daily logs into weekly summaries, and old weekly summaries
+ * into monthly summaries. During weekly compaction, durable knowledge
+ * is extracted into typed memory files.
+ *
+ * Compaction pipeline:
+ *   daily logs (7 days) → weekly summary (kept 52 weeks)
+ *   weekly summaries (>52 weeks) → monthly summary (kept permanently)
+ */
+import { mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+/**
+ * Get ISO week number and year for a date.
+ * Returns { year, week } where week is 1-53.
+ */
+function getISOWeek(date) {
+    const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+    d.setUTCDate(d.getUTCDate() + 4 - (d.getUTCDay() || 7));
+    const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+    const week = Math.ceil(((d.getTime() - yearStart.getTime()) / 86400000 + 1) / 7);
+    return { year: d.getUTCFullYear(), week };
+}
+/**
+ * Format a week number as YYYY-Wnn.
+ */
+function formatWeek(year, week) {
+    return `${year}-W${week.toString().padStart(2, "0")}`;
+}
+/**
+ * Group daily logs by ISO week.
+ */
+function groupDailiesByWeek(dailies) {
+    const groups = new Map();
+    for (const daily of dailies) {
+        const d = new Date(`${daily.date}T00:00:00Z`);
+        const { year, week } = getISOWeek(d);
+        const key = formatWeek(year, week);
+        const group = groups.get(key) ?? [];
+        group.push(daily);
+        groups.set(key, group);
+    }
+    return groups;
+}
+/**
+ * Group weekly summaries by month (YYYY-MM).
+ */
+function groupWeekliesByMonth(weeklies) {
+    const groups = new Map();
+    for (const weekly of weeklies) {
+        // Parse YYYY-Wnn to get approximate month from the Thursday of that week
+        const match = weekly.week.match(/^(\d{4})-W(\d{2})$/);
+        if (!match)
+            continue;
+        const year = parseInt(match[1], 10);
+        const weekNum = parseInt(match[2], 10);
+        // ISO week date: Jan 4 is always in week 1
+        const jan4 = new Date(Date.UTC(year, 0, 4));
+        const dayOfWeek = jan4.getUTCDay() || 7;
+        const monday = new Date(jan4);
+        monday.setUTCDate(jan4.getUTCDate() - dayOfWeek + 1 + (weekNum - 1) * 7);
+        const thursday = new Date(monday);
+        thursday.setUTCDate(monday.getUTCDate() + 3);
+        const month = `${thursday.getUTCFullYear()}-${(thursday.getUTCMonth() + 1).toString().padStart(2, "0")}`;
+        const group = groups.get(month) ?? [];
+        group.push(weekly);
+        groups.set(month, group);
+    }
+    return groups;
+}
+/**
+ * Build a weekly summary from daily logs.
+ * This is a structural concatenation — the agent can refine it afterward.
+ */
+function buildWeeklySummary(weekKey, dailies) {
+    // Sort chronologically
+    const sorted = [...dailies].sort((a, b) => a.date.localeCompare(b.date));
+    const firstDate = sorted[0].date;
+    const lastDate = sorted[sorted.length - 1].date;
+    const lines = [];
+    lines.push("---");
+    lines.push(`type: weekly`);
+    lines.push(`week: ${weekKey}`);
+    lines.push(`period: ${firstDate} to ${lastDate}`);
+    lines.push("---");
+    lines.push("");
+    lines.push(`# Week ${weekKey}`);
+    lines.push("");
+    for (const daily of sorted) {
+        lines.push(`## ${daily.date}`);
+        lines.push("");
+        lines.push(daily.content.trim());
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/**
+ * Build a monthly summary from weekly summaries.
+ */
+function buildMonthlySummary(monthKey, weeklies) {
+    const sorted = [...weeklies].sort((a, b) => a.week.localeCompare(b.week));
+    const firstWeek = sorted[0].week;
+    const lastWeek = sorted[sorted.length - 1].week;
+    const lines = [];
+    lines.push("---");
+    lines.push(`type: monthly`);
+    lines.push(`month: ${monthKey}`);
+    lines.push(`period: ${firstWeek} to ${lastWeek}`);
+    lines.push("---");
+    lines.push("");
+    lines.push(`# Month ${monthKey}`);
+    lines.push("");
+    for (const weekly of sorted) {
+        // Strip frontmatter from weekly content before including
+        const content = weekly.content.replace(/^---[\s\S]*?---\s*\n/, "").trim();
+        lines.push(content);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/**
+ * Compact daily logs into weekly summaries for a single teammate.
+ * Only compacts complete weeks (not the current week).
+ */
+export async function compactDailies(teammateDir) {
+    const memoryDir = join(teammateDir, "memory");
+    const weeklyDir = join(memoryDir, "weekly");
+    // Read all daily logs
+    const entries = await readdir(memoryDir).catch(() => []);
+    const dailies = [];
+    for (const entry of entries) {
+        if (!entry.endsWith(".md"))
+            continue;
+        const stem = basename(entry, ".md");
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(stem))
+            continue;
+        const content = await readFile(join(memoryDir, entry), "utf-8");
+        dailies.push({ date: stem, content, file: entry });
+    }
+    if (dailies.length === 0)
+        return { created: [], removed: [] };
+    // Group by ISO week
+    const groups = groupDailiesByWeek(dailies);
+    // Determine current week — don't compact it
+    const now = new Date();
+    const { year: curYear, week: curWeek } = getISOWeek(now);
+    const currentWeek = formatWeek(curYear, curWeek);
+    // Check which weekly summaries already exist
+    const existingWeeklies = new Set();
+    try {
+        const wEntries = await readdir(weeklyDir);
+        for (const e of wEntries) {
+            if (e.endsWith(".md"))
+                existingWeeklies.add(basename(e, ".md"));
+        }
+    }
+    catch {
+        // No weekly dir yet
+    }
+    const created = [];
+    const removed = [];
+    for (const [weekKey, weekDailies] of groups) {
+        // Skip current week
+        if (weekKey === currentWeek)
+            continue;
+        // Skip if weekly summary already exists
+        if (existingWeeklies.has(weekKey))
+            continue;
+        // Create weekly dir if needed
+        await mkdir(weeklyDir, { recursive: true });
+        // Build and write weekly summary
+        const summary = buildWeeklySummary(weekKey, weekDailies);
+        const weeklyFile = join(weeklyDir, `${weekKey}.md`);
+        await writeFile(weeklyFile, summary, "utf-8");
+        created.push(`${weekKey}.md`);
+        // Delete the daily logs that were compacted
+        for (const daily of weekDailies) {
+            await unlink(join(memoryDir, daily.file)).catch(() => { });
+            removed.push(daily.file);
+        }
+    }
+    return { created, removed };
+}
+/**
+ * Compact weekly summaries older than 52 weeks into monthly summaries.
+ */
+export async function compactWeeklies(teammateDir) {
+    const memoryDir = join(teammateDir, "memory");
+    const weeklyDir = join(memoryDir, "weekly");
+    const monthlyDir = join(memoryDir, "monthly");
+    // Read all weekly summaries
+    let entries;
+    try {
+        entries = await readdir(weeklyDir);
+    }
+    catch {
+        return { created: [], removed: [] };
+    }
+    const weeklies = [];
+    for (const entry of entries) {
+        if (!entry.endsWith(".md"))
+            continue;
+        const stem = basename(entry, ".md");
+        if (!/^\d{4}-W\d{2}$/.test(stem))
+            continue;
+        const content = await readFile(join(weeklyDir, entry), "utf-8");
+        weeklies.push({ week: stem, content, file: entry });
+    }
+    if (weeklies.length === 0)
+        return { created: [], removed: [] };
+    // Determine cutoff: 52 weeks ago
+    const now = new Date();
+    const cutoff = new Date(now);
+    cutoff.setDate(cutoff.getDate() - 52 * 7);
+    const { year: cutYear, week: cutWeek } = getISOWeek(cutoff);
+    const cutoffWeek = formatWeek(cutYear, cutWeek);
+    // Filter to old weeklies only
+    const oldWeeklies = weeklies.filter((w) => w.week < cutoffWeek);
+    if (oldWeeklies.length === 0)
+        return { created: [], removed: [] };
+    // Group by month
+    const groups = groupWeekliesByMonth(oldWeeklies);
+    // Check existing monthlies
+    const existingMonthlies = new Set();
+    try {
+        const mEntries = await readdir(monthlyDir);
+        for (const e of mEntries) {
+            if (e.endsWith(".md"))
+                existingMonthlies.add(basename(e, ".md"));
+        }
+    }
+    catch {
+        // No monthly dir yet
+    }
+    const created = [];
+    const removed = [];
+    for (const [monthKey, monthWeeklies] of groups) {
+        if (existingMonthlies.has(monthKey))
+            continue;
+        await mkdir(monthlyDir, { recursive: true });
+        const summary = buildMonthlySummary(monthKey, monthWeeklies);
+        const monthlyFile = join(monthlyDir, `${monthKey}.md`);
+        await writeFile(monthlyFile, summary, "utf-8");
+        created.push(`${monthKey}.md`);
+        // Delete the old weekly files
+        for (const weekly of monthWeeklies) {
+            await unlink(join(weeklyDir, weekly.file)).catch(() => { });
+            removed.push(weekly.file);
+        }
+    }
+    return { created, removed };
+}
+/**
+ * Run full episodic compaction for a teammate:
+ * 1. Compact completed weeks' dailies → weekly summaries
+ * 2. Compact weeklies older than 52 weeks → monthly summaries
+ */
+export async function compactEpisodic(teammateDir, teammateName) {
+    const dailyResult = await compactDailies(teammateDir);
+    const weeklyResult = await compactWeeklies(teammateDir);
+    return {
+        teammate: teammateName,
+        weekliesCreated: dailyResult.created,
+        monthliesCreated: weeklyResult.created,
+        dailiesRemoved: dailyResult.removed,
+        weekliesRemoved: weeklyResult.removed,
+    };
+}

package/dist/compact.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/compact.test.js

@@ -0,0 +1,198 @@
+import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { compactDailies, compactEpisodic, compactWeeklies } from "./compact.js";
+let testDir;
+beforeEach(async () => {
+    testDir = join(tmpdir(), `compact-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    await mkdir(testDir, { recursive: true });
+});
+afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+});
+// Verified ISO weeks: 2024-03-05 (Tue)=W10, 2024-03-06 (Wed)=W10, 2024-03-07 (Thu)=W10
+//                     2024-03-12 (Tue)=W11, 2024-03-13 (Wed)=W11
+describe("compactDailies", () => {
+    it("creates weekly summary from completed week's dailies", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        // All three in ISO 2024-W10
+        await writeFile(join(memDir, "2024-03-05.md"), "# Tuesday\nDid stuff");
+        await writeFile(join(memDir, "2024-03-06.md"), "# Wednesday\nDid more stuff");
+        await writeFile(join(memDir, "2024-03-07.md"), "# Thursday\nDid even more");
+        const result = await compactDailies(testDir);
+        expect(result.created).toHaveLength(1);
+        expect(result.created[0]).toBe("2024-W10.md");
+        expect(result.removed).toHaveLength(3);
+        expect(result.removed).toContain("2024-03-05.md");
+        expect(result.removed).toContain("2024-03-06.md");
+        expect(result.removed).toContain("2024-03-07.md");
+        // Verify the weekly summary was actually written
+        const weeklyDir = join(memDir, "weekly");
+        const weeklyFiles = await readdir(weeklyDir);
+        expect(weeklyFiles).toHaveLength(1);
+        const content = await readFile(join(weeklyDir, weeklyFiles[0]), "utf-8");
+        expect(content).toContain("type: weekly");
+        expect(content).toContain("2024-03-05");
+        expect(content).toContain("Did stuff");
+        expect(content).toContain("Did more stuff");
+    });
+    it("does not compact current week's dailies", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        const today = new Date().toISOString().slice(0, 10);
+        await writeFile(join(memDir, `${today}.md`), "# Today\nDoing stuff");
+        const result = await compactDailies(testDir);
+        expect(result.created).toHaveLength(0);
+        expect(result.removed).toHaveLength(0);
+    });
+    it("groups dailies into separate weeks", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        // W10: Mar 5-6, W11: Mar 12-13
+        await writeFile(join(memDir, "2024-03-05.md"), "# W10 day1");
+        await writeFile(join(memDir, "2024-03-06.md"), "# W10 day2");
+        await writeFile(join(memDir, "2024-03-12.md"), "# W11 day1");
+        await writeFile(join(memDir, "2024-03-13.md"), "# W11 day2");
+        const result = await compactDailies(testDir);
+        expect(result.created).toHaveLength(2);
+        expect(result.removed).toHaveLength(4);
+    });
+    it("skips weeks that already have a weekly summary", async () => {
+        const memDir = join(testDir, "memory");
+        const weeklyDir = join(memDir, "weekly");
+        await mkdir(weeklyDir, { recursive: true });
+        await writeFile(join(memDir, "2024-03-05.md"), "# Day 1");
+        // Pre-existing weekly summary for W10
+        await writeFile(join(weeklyDir, "2024-W10.md"), "# Already compacted");
+        const result = await compactDailies(testDir);
+        expect(result.created).toHaveLength(0);
+        expect(result.removed).toHaveLength(0);
+    });
+    it("returns empty when no daily logs exist", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        await writeFile(join(memDir, "feedback_test.md"), "# Not a daily");
+        const result = await compactDailies(testDir);
+        expect(result.created).toHaveLength(0);
+        expect(result.removed).toHaveLength(0);
+    });
+    it("returns empty when memory dir doesn't exist", async () => {
+        const result = await compactDailies(testDir);
+        expect(result.created).toEqual([]);
+        expect(result.removed).toEqual([]);
+    });
+    it("builds weekly summary with correct frontmatter and chronological order", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        // Write out of order — compaction should sort chronologically
+        await writeFile(join(memDir, "2024-03-07.md"), "# Thursday entry");
+        await writeFile(join(memDir, "2024-03-05.md"), "# Tuesday entry");
+        await writeFile(join(memDir, "2024-03-06.md"), "# Wednesday entry");
+        await compactDailies(testDir);
+        const weeklyDir = join(memDir, "weekly");
+        const files = await readdir(weeklyDir);
+        const content = await readFile(join(weeklyDir, files[0]), "utf-8");
+        // Check frontmatter
+        expect(content).toMatch(/^---\n/);
+        expect(content).toContain("type: weekly");
+        expect(content).toContain("week: 2024-W10");
+        expect(content).toContain("period: 2024-03-05 to 2024-03-07");
+        // Check chronological order
+        const tuesdayIdx = content.indexOf("Tuesday entry");
+        const wednesdayIdx = content.indexOf("Wednesday entry");
+        const thursdayIdx = content.indexOf("Thursday entry");
+        expect(tuesdayIdx).toBeLessThan(wednesdayIdx);
+        expect(wednesdayIdx).toBeLessThan(thursdayIdx);
+    });
+});
+describe("compactWeeklies", () => {
+    it("compacts weeklies older than 52 weeks into monthly summary", async () => {
+        const weeklyDir = join(testDir, "memory", "weekly");
+        await mkdir(weeklyDir, { recursive: true });
+        // ~2 years ago — definitely older than 52 weeks
+        await writeFile(join(weeklyDir, "2023-W10.md"), "---\ntype: weekly\nweek: 2023-W10\n---\n# Week 10\nStuff");
+        await writeFile(join(weeklyDir, "2023-W11.md"), "---\ntype: weekly\nweek: 2023-W11\n---\n# Week 11\nMore stuff");
+        const result = await compactWeeklies(testDir);
+        expect(result.created.length).toBeGreaterThanOrEqual(1);
+        expect(result.removed).toHaveLength(2);
+        expect(result.removed).toContain("2023-W10.md");
+        expect(result.removed).toContain("2023-W11.md");
+        // Verify monthly summary was written
+        const monthlyDir = join(testDir, "memory", "monthly");
+        const monthlyFiles = await readdir(monthlyDir);
+        expect(monthlyFiles.length).toBeGreaterThanOrEqual(1);
+        const content = await readFile(join(monthlyDir, monthlyFiles[0]), "utf-8");
+        expect(content).toContain("type: monthly");
+    });
+    it("does not compact recent weeklies", async () => {
+        const weeklyDir = join(testDir, "memory", "weekly");
+        await mkdir(weeklyDir, { recursive: true });
+        // Use current year — should be within 52 weeks
+        const now = new Date();
+        const year = now.getFullYear();
+        await writeFile(join(weeklyDir, `${year}-W10.md`), `---\ntype: weekly\nweek: ${year}-W10\n---\n# Recent`);
+        const result = await compactWeeklies(testDir);
+        expect(result.created).toHaveLength(0);
+        expect(result.removed).toHaveLength(0);
+    });
+    it("returns empty when no weekly dir exists", async () => {
+        const result = await compactWeeklies(testDir);
+        expect(result.created).toEqual([]);
+        expect(result.removed).toEqual([]);
+    });
+    it("skips months that already have a monthly summary", async () => {
+        const weeklyDir = join(testDir, "memory", "weekly");
+        const monthlyDir = join(testDir, "memory", "monthly");
+        await mkdir(weeklyDir, { recursive: true });
+        await mkdir(monthlyDir, { recursive: true });
+        await writeFile(join(weeklyDir, "2023-W10.md"), "---\ntype: weekly\nweek: 2023-W10\n---\n# W10");
+        await writeFile(join(monthlyDir, "2023-03.md"), "# Already compacted");
+        const result = await compactWeeklies(testDir);
+        // The monthly for 2023-03 already exists
+        const created = result.created.filter((f) => f === "2023-03.md");
+        expect(created).toHaveLength(0);
+    });
+    it("strips frontmatter from weekly content in monthly summary", async () => {
+        const weeklyDir = join(testDir, "memory", "weekly");
+        await mkdir(weeklyDir, { recursive: true });
+        const weeklyContent = "---\ntype: weekly\nweek: 2023-W10\nperiod: 2023-03-06 to 2023-03-10\n---\n\n# Week 2023-W10\n\nSome work was done.";
+        await writeFile(join(weeklyDir, "2023-W10.md"), weeklyContent);
+        const result = await compactWeeklies(testDir);
+        if (result.created.length > 0) {
+            const monthlyDir = join(testDir, "memory", "monthly");
+            const monthlyFiles = await readdir(monthlyDir);
+            const content = await readFile(join(monthlyDir, monthlyFiles[0]), "utf-8");
+            // Monthly should have its own frontmatter but NOT the weekly's
+            expect(content).toContain("type: monthly");
+            expect(content).not.toContain("type: weekly");
+            expect(content).toContain("Some work was done.");
+        }
+    });
+});
+describe("compactEpisodic", () => {
+    it("runs both daily and weekly compaction", async () => {
+        const memDir = join(testDir, "memory");
+        await mkdir(memDir, { recursive: true });
+        // Both in ISO 2024-W10
+        await writeFile(join(memDir, "2024-03-05.md"), "# Day 1");
+        await writeFile(join(memDir, "2024-03-06.md"), "# Day 2");
+        const result = await compactEpisodic(testDir, "test");
+        expect(result.teammate).toBe("test");
+        expect(result.weekliesCreated).toHaveLength(1);
+        expect(result.dailiesRemoved).toHaveLength(2);
+        // The newly created weekly (2024-W10) is >52 weeks old, so compactWeeklies
+        // immediately compacts it into a monthly summary
+        expect(result.monthliesCreated).toHaveLength(1);
+        expect(result.weekliesRemoved).toHaveLength(1);
+    });
+    it("returns empty results for teammate with no memory", async () => {
+        const result = await compactEpisodic(testDir, "empty");
+        expect(result.teammate).toBe("empty");
+        expect(result.weekliesCreated).toEqual([]);
+        expect(result.monthliesCreated).toEqual([]);
+        expect(result.dailiesRemoved).toEqual([]);
+        expect(result.weekliesRemoved).toEqual([]);
+    });
+});

package/dist/console/ansi.d.ts

@@ -0,0 +1,18 @@
+/**
+ * ANSI helpers — re-exports from consolonia plus CLI-specific extras.
+ */
+import { stripAnsi, truncateAnsi, visibleLength } from "@teammates/consolonia";
+export { stripAnsi, truncateAnsi, visibleLength };
+export declare const cursorUp: (n?: number) => string;
+export declare const cursorDown: (n?: number) => string;
+export declare const eraseLine = "\u001B[2K";
+export declare const eraseDown = "\u001B[0J";
+export declare const eraseScreen = "\u001B[2J";
+/** Move cursor to absolute column (1-based). */
+export declare const cursorToCol: (col: number) => string;
+/** Erase from cursor to end of line. */
+export declare const eraseToEnd = "\u001B[0K";
+/** Move cursor to home (0,0). */
+export declare const cursorHome = "\u001B[H";
+/** Carriage return. */
+export declare const cr = "\r";

package/dist/console/ansi.js

@@ -0,0 +1,20 @@
+/**
+ * ANSI helpers — re-exports from consolonia plus CLI-specific extras.
+ */
+import { esc, stripAnsi, truncateAnsi, visibleLength, } from "@teammates/consolonia";
+// ── Re-exports from consolonia ──────────────────────────────────
+export { stripAnsi, truncateAnsi, visibleLength };
+export const cursorUp = (n = 1) => esc.moveUp(n);
+export const cursorDown = (n = 1) => esc.moveDown(n);
+export const eraseLine = esc.eraseLine;
+export const eraseDown = esc.eraseDown;
+export const eraseScreen = esc.clearScreen;
+// ── CLI-specific (not in consolonia) ────────────────────────────
+/** Move cursor to absolute column (1-based). */
+export const cursorToCol = (col) => `\x1b[${col}G`;
+/** Erase from cursor to end of line. */
+export const eraseToEnd = "\x1b[0K";
+/** Move cursor to home (0,0). */
+export const cursorHome = "\x1b[H";
+/** Carriage return. */
+export const cr = "\r";

package/dist/console/ansi.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/console/ansi.test.js

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import { cursorDown, cursorToCol, cursorUp } from "./ansi.js";
+describe("cursorUp", () => {
+    it("produces correct escape for n=1", () => {
+        expect(cursorUp(1)).toBe("\x1b[1A");
+    });
+    it("produces correct escape for n=5", () => {
+        expect(cursorUp(5)).toBe("\x1b[5A");
+    });
+    it("uses default n=1 when called with no arguments", () => {
+        expect(cursorUp()).toBe("\x1b[1A");
+    });
+    it("handles n=0", () => {
+        expect(cursorUp(0)).toBe("\x1b[0A");
+    });
+    it("handles large n", () => {
+        expect(cursorUp(100)).toBe("\x1b[100A");
+    });
+});
+describe("cursorDown", () => {
+    it("produces correct escape for n=1", () => {
+        expect(cursorDown(1)).toBe("\x1b[1B");
+    });
+    it("produces correct escape for n=3", () => {
+        expect(cursorDown(3)).toBe("\x1b[3B");
+    });
+    it("uses default n=1 when called with no arguments", () => {
+        expect(cursorDown()).toBe("\x1b[1B");
+    });
+    it("handles n=0", () => {
+        expect(cursorDown(0)).toBe("\x1b[0B");
+    });
+    it("handles large n", () => {
+        expect(cursorDown(500)).toBe("\x1b[500B");
+    });
+});
+describe("cursorToCol", () => {
+    it("produces correct escape for col=1", () => {
+        expect(cursorToCol(1)).toBe("\x1b[1G");
+    });
+    it("produces correct escape for col=10", () => {
+        expect(cursorToCol(10)).toBe("\x1b[10G");
+    });
+    it("handles col=0", () => {
+        expect(cursorToCol(0)).toBe("\x1b[0G");
+    });
+    it("handles large col", () => {
+        expect(cursorToCol(999)).toBe("\x1b[999G");
+    });
+});

package/dist/console/dropdown.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Dropdown — renders lines below the readline prompt without disrupting input.
+ *
+ * Hooks readline's internal _refreshLine to append dropdown content below
+ * the prompt, then repositions the cursor back to the input line.
+ *
+ * Works on both Windows and macOS terminals.
+ */
+import type { Interface as ReadlineInterface } from "node:readline";
+export declare class Dropdown {
+    private rl;
+    private lines;
+    private out;
+    private refreshing;
+    constructor(rl: ReadlineInterface);
+    /** Number of lines currently rendered below the prompt. */
+    get rendered(): number;
+    /** Set dropdown content and trigger a re-render. */
+    render(newLines: string[]): void;
+    /** Clear dropdown content. Next _refreshLine won't append anything. */
+    clear(): void;
+    private installHook;
+}