jules-ink 0.0.2

package/README.md

@@ -0,0 +1,115 @@
+# Jules Ink 🖨️
+
+**Print physical labels of your AI coding sessions.** Jules Ink connects to [Jules](https://jules.google.com) sessions, generates AI-powered summaries, and prints them to thermal label printers.
+
+![grumpy-cat](./assets/labels/grumpy-cat.png)
+
+## Why?
+
+Because watching an AI write code is cool. But having a **physical artifact** of what it did? That's cooler.
+
+- 📝 **Document your AI pair programming** — Keep a tangible record of what Jules built
+- 🎉 **Make it fun** — Print summaries as a pirate, Shakespeare, or a noir detective
+- 🏷️ **Label your commits** — Stick them on your monitor, notebook, or fridge
+
+## Quick Start
+
+```bash
+# Install dependencies
+npm install
+
+# Set your API key
+export GEMINI_API_KEY="your-key"
+export JULES_API_KEY="jules-key"
+
+jules-ink print --session <SESSION_ID> -t haiku
+```
+
+## CLI Options
+
+```
+Usage: jules-ink print [options]
+
+Options:
+  -s, --session <id>    Session ID to process (required)
+  -m, --model <name>    Gemini model (default: "gemini-2.5-flash-lite")
+  -t, --tone <preset>   Tone for summaries (default: "professional")
+  -p, --printer <name>  Printer name (auto-discovers if not set)
+  -h, --help            Display help
+```
+
+## Tone Presets
+
+Make your labels fun with built-in tone presets:
+
+| Tone | Example Output |
+|------|----------------|
+| `professional` | "Refactoring `SessionClient` to support new handshake protocol." |
+| `pirate` | "Arr! We be refactorin' the `SessionClient`, matey!" |
+| `shakespearean` | "Hark! The `SessionClient` doth receive new methods most fair." |
+| `excited` | "OMG!! 🎉 Just refactored `SessionClient`!!! SO EXCITING!!! 🚀" |
+| `haiku` | "Code flows like a stream / SessionClient transforms / Bugs fade to nothing" |
+| `noir` | "The function had seen better days. I gave it a new life." |
+
+### Custom Tones
+
+Pass any string to `-t` for a custom tone:
+
+```bash
+# Characters
+jules-ink print -s 123456 -t "Respond as if you're a grumpy cat"
+jules-ink print -s 123456 -t "Write like a sports commentator at a tied match in extra time"
+jules-ink print -s 123456 -t "Write like a nature documentary narrator observing code in its natural habitat"
+jules-ink print -s 123456 -t "Respond like a dramatic movie trailer voiceover"
+jules-ink print -s 123456 -t "Write as a medieval herald announcing royal decrees"
+
+# Professions & styles
+jules-ink print -s 123456 -t "Write like a sports commentator at a tied match in extra time"
+jules-ink print -s 123456 -t "Respond as a surfer dude who just discovered coding"
+jules-ink print -s 123456 -t "Write like a food critic reviewing a gourmet meal"
+jules-ink print -s 123456 -t "Respond as an overly enthusiastic infomercial host"
+jules-ink print -s 123456 -t "Respond like a soap opera actor"
+
+# Moods & vibes
+jules-ink print -s 123456 -t "Write with the energy of someone who just had 5 espressos"
+jules-ink print -s 123456 -t "Respond like a wise grandparent telling stories by the fire"
+jules-ink print -s 123456 -t "Write as if you're whispering secrets at a library"
+jules-ink print -s 123456 -t "Respond with the dramatic flair of a telenovela narrator"
+```
+
+## Use Cases
+
+### 1. Physical Commit Log
+
+Print a label for each coding session and stick them in a notebook:
+
+```bash
+jules-ink print -s 561934200180369816 at a tied match in extra time9
+jules-ink print -s 5619342001803698169
+```
+
+### 2. Fun Team Activity
+
+Have Jules write code, then print the summary as a haiku:
+
+```bash
+jules-ink print -s 5619342001803698169 -t haik at a tied match in extra timeu
+jules-ink print -s 5619342001803698169 -t haiku
+```
+
+## Printer Setup
+
+Jules Ink works with thermal label printers via CUPS. The default target is `PM-241-BT` (a common Bluetooth thermal printer).
+
+If no printer is found, labels are saved to `output/<session-id>/` as PNG files.
+
+## Requirements
+
+- Node.js 18+
+- `GEMINI_API_KEY` environment variable
+- `JULES_API_KEY` environment variable
+- (Optional) Thermal label printer
+
+## License
+
+MIT

package/dist/analyzer.d.ts

@@ -0,0 +1,6 @@
+import { ChangeSetSummary } from './types.js';
+/**
+ * Transforms a raw Unidiff string into structured stats,
+ * filtering out noise to match the Summarizer's logic.
+ */
+export declare function analyzeChangeSet(unidiffPatch: string): ChangeSetSummary;

package/dist/analyzer.js

@@ -0,0 +1,55 @@
+import parseDiff from 'parse-diff';
+import micromatch from 'micromatch';
+// 1. Define the same Ignore Patterns used in your Summarizer
+const IGNORE_PATTERNS = [
+    '**/package-lock.json',
+    '**/yarn.lock',
+    '**/*.map',
+    '**/dist/**',
+    '**/*.min.js',
+    '**/.DS_Store'
+];
+/**
+ * Transforms a raw Unidiff string into structured stats,
+ * filtering out noise to match the Summarizer's logic.
+ */
+export function analyzeChangeSet(unidiffPatch) {
+    // parse-diff handles the heavy lifting
+    const parsedFiles = parseDiff(unidiffPatch);
+    const files = [];
+    let totalInsertions = 0;
+    let totalDeletions = 0;
+    for (const file of parsedFiles) {
+        // Prioritize 'to' path (new file), fallback to 'from' (deleted file)
+        const path = file.to || file.from || 'unknown';
+        // 2. APPLY FILTER LOGIC (Match simplifyActivity)
+        // If it's a lockfile or noise, skip it completely. 
+        // We don't want these taking up space on the physical label.
+        if (micromatch.isMatch(path, IGNORE_PATTERNS)) {
+            continue;
+        }
+        // Handle binary files or renames where stats might be ambiguous
+        const additions = file.additions || 0;
+        const deletions = file.deletions || 0;
+        totalInsertions += additions;
+        totalDeletions += deletions;
+        // 3. REMOVED GRAPH LOGIC
+        // We no longer calculate block chars. We just pass the raw stats.
+        files.push({
+            path,
+            additions,
+            deletions,
+            totalChanges: additions + deletions
+        });
+    }
+    // Sort files by "impact" (most changes first) so the label shows the important stuff
+    files.sort((a, b) => b.totalChanges - a.totalChanges);
+    return {
+        files,
+        totalFiles: files.length,
+        totalInsertions,
+        totalDeletions,
+        // Updated summary string to match the new numeric style
+        summaryString: `${files.length} files | +${totalInsertions} / -${totalDeletions}`
+    };
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { processSessionAndPrint } from './pipeline.js';
+const program = new Command();
+program
+    .name('jules-ink')
+    .description('Label Pipeline CLI for processing Jules sessions')
+    .version('0.0.0');
+program
+    .command('print')
+    .description('Print labels for a Jules session')
+    .requiredOption('-s, --session <id>', 'The Session ID to process')
+    .option('-m, --model <name>', 'Gemini model to use for summarization', 'gemini-2.5-flash-lite')
+    .option('-t, --tone <preset>', 'Tone preset for summaries (professional, pirate, shakespearean, excited, haiku, noir)', 'professional')
+    .option('-p, --printer <name>', 'Printer name (auto-discovers if not set)')
+    .action(async (options) => {
+    const sessionId = options.session;
+    const model = options.model;
+    const tone = options.tone;
+    const printer = options.printer;
+    console.log(`\n🚀 Starting Label Pipeline for Session: ${sessionId}`);
+    console.log(`📦 Using model: ${model}`);
+    console.log(`🎭 Tone: ${tone}`);
+    console.log(`===================================================\n`);
+    try {
+        const generator = processSessionAndPrint(sessionId, { model, tone, printer });
+        for await (const result of generator) {
+            console.log(`✓ [${result.activity.type}] Processed`);
+            console.log(`  └─ Summary: "${result.summary.substring(0, 60)}..."`);
+            console.log(`  └─ Label:   ${result.labelPath}\n`);
+        }
+        console.log(`✅ Session ${sessionId} processing complete.`);
+    }
+    catch (error) {
+        console.error('\n❌ Fatal Error processing session:', error);
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/label-generator.d.ts

@@ -0,0 +1,12 @@
+export interface FileStat {
+    path: string;
+    additions: number;
+    deletions: number;
+}
+export interface LabelData {
+    repo: string;
+    sessionId: string;
+    summary: string;
+    files: FileStat[];
+}
+export declare function generateLabel(data: LabelData): Promise<Buffer>;

package/dist/label-generator.js

@@ -0,0 +1,190 @@
+import { createCanvas, loadImage, GlobalFonts } from '@napi-rs/canvas';
+import path from 'path';
+import fs from 'fs';
+import { truncateMiddle } from './utils.js';
+import { parseMarkdownSegments, calculateWrappedSegments } from './utils.js';
+// --- Font Registration ---
+const FONT_DIR = path.resolve('./assets/fonts');
+function registerLocalFont(filename, family) {
+    const filePath = path.join(FONT_DIR, filename);
+    if (fs.existsSync(filePath))
+        GlobalFonts.registerFromPath(filePath, family);
+}
+registerLocalFont('GoogleSans-Bold.ttf', 'Google Sans');
+registerLocalFont('GoogleSans-Regular.ttf', 'Google Sans');
+registerLocalFont('GoogleSansMono-Regular.ttf', 'Google Sans Mono');
+// Emoji font fallback (uses system fonts)
+const EMOJI_FALLBACK = ', "Apple Color Emoji", "Segoe UI Emoji", "Noto Color Emoji"';
+// --- Configuration ---
+const CONFIG = {
+    width: 1200,
+    height: 1800,
+    padding: 64,
+    fonts: {
+        header: `36px "Google Sans Mono", monospace${EMOJI_FALLBACK}`,
+        stats: `42px "Google Sans Mono", monospace${EMOJI_FALLBACK}`,
+    },
+    layout: {
+        headerY: 120,
+        // ANCHOR 1: Logo Bottom
+        logoBottomY: 520,
+        // ANCHOR 2: Body Start
+        bodyGap: 24,
+        // ANCHOR 3: Stats Start
+        statsY: 1350,
+        // NEW: The "DMZ"
+        // The text body is forced to stop this many pixels BEFORE statsY.
+        // Increased from implicit 40px to explicit 100px.
+        minGapBetweenBodyAndStats: 100,
+        footerLineHeight: 65
+    }
+};
+export async function generateLabel(data) {
+    const canvas = createCanvas(CONFIG.width, CONFIG.height);
+    const ctx = canvas.getContext('2d');
+    const templatePath = path.resolve('./assets/template.png');
+    if (fs.existsSync(templatePath)) {
+        const template = await loadImage(templatePath);
+        ctx.drawImage(template, 0, 0, CONFIG.width, CONFIG.height);
+    }
+    else {
+        ctx.fillStyle = 'white';
+        ctx.fillRect(0, 0, CONFIG.width, CONFIG.height);
+    }
+    ctx.fillStyle = 'black';
+    drawHeader(ctx, data.repo, data.sessionId);
+    // 1. Calculate Body Start
+    const bodyStartY = CONFIG.layout.logoBottomY + CONFIG.layout.bodyGap;
+    // 2. Calculate Max Height with DMZ
+    // Logic: Stats Start - Start Y - The Mandatory Gap
+    const maxBodyHeight = CONFIG.layout.statsY - bodyStartY - CONFIG.layout.minGapBetweenBodyAndStats;
+    // 3. Draw Body
+    // The text will shrink itself until it fits nicely inside this smaller box
+    drawBodyAnchored(ctx, data.summary, bodyStartY, maxBodyHeight);
+    // 4. Draw Stats
+    if (data.files && data.files.length > 0) {
+        drawStatsFixed(ctx, data.files, CONFIG.layout.statsY);
+    }
+    return canvas.toBuffer('image/png');
+}
+function drawHeader(ctx, repo, sessionId) {
+    const { width, padding } = CONFIG;
+    ctx.font = CONFIG.fonts.header;
+    ctx.textAlign = 'right';
+    ctx.fillText(sessionId, width - padding, CONFIG.layout.headerY);
+    const sessionWidth = ctx.measureText(sessionId).width;
+    const maxRepoWidth = width - (padding * 2) - sessionWidth - 40;
+    let fontSize = 36;
+    ctx.font = `${fontSize}px "Google Sans Mono", monospace`;
+    while (ctx.measureText(repo).width > maxRepoWidth && fontSize > 20) {
+        fontSize -= 2;
+        ctx.font = `${fontSize}px "Google Sans Mono", monospace`;
+    }
+    ctx.textAlign = 'left';
+    ctx.fillText(repo, padding, CONFIG.layout.headerY);
+}
+function drawBodyAnchored(ctx, text, fixedY, maxHeight) {
+    const maxWidth = CONFIG.width - (CONFIG.padding * 2);
+    // 1. Parse raw text into typed segments
+    const allSegments = parseMarkdownSegments(text);
+    // Constraints
+    let fontSize = 80;
+    const minFontSize = 38;
+    const lineHeightMultiplier = 1.4;
+    let wrappedLines = [];
+    let lineHeight = 0;
+    let totalTextHeight = 0;
+    let weight = 'bold';
+    let normalFontStr = '';
+    // Monospace font size should match body size roughly
+    let codeFontStr = '';
+    // 2. Shrink Loop (Now uses segment wrapper)
+    do {
+        weight = fontSize > 60 ? 'bold' : 'normal';
+        normalFontStr = `${weight} ${fontSize}px "Google Sans"${EMOJI_FALLBACK}`;
+        // Use slightly smaller font for mono so it doesn't overpower the text
+        codeFontStr = `normal ${fontSize - 4}px "Google Sans Mono"${EMOJI_FALLBACK}`;
+        // Use new wrapper that understands mixed fonts
+        wrappedLines = calculateWrappedSegments(ctx, allSegments, maxWidth, normalFontStr, codeFontStr);
+        lineHeight = Math.floor(fontSize * lineHeightMultiplier);
+        totalTextHeight = wrappedLines.length * lineHeight;
+        if (totalTextHeight > maxHeight) {
+            fontSize -= 4;
+        }
+        else {
+            break;
+        }
+    } while (fontSize >= minFontSize);
+    // (Truncation logic omitted for brevity, but would need updating for segments)
+    // 3. Drawing Phase
+    ctx.textAlign = 'left';
+    ctx.fillStyle = 'black';
+    let currentY = fixedY;
+    // Iterate over each line
+    for (const lineSegments of wrappedLines) {
+        let currentX = CONFIG.padding;
+        // Iterate over segments within the line
+        for (const segment of lineSegments) {
+            if (segment.isCode) {
+                // --- DRAW CODE SPAN ---
+                ctx.font = codeFontStr;
+                // Recalculate width just to be safe for drawing
+                const metric = ctx.measureText(segment.text);
+                const textWidth = metric.width;
+                const boxWidth = textWidth + 12; // 6px padding each side
+                // Calculate box height relative to font size
+                const boxHeight = fontSize * 1.1;
+                // Offset y up slightly to center text vertically in box
+                const boxYOffset = fontSize * 0.9;
+                // Draw Background Box
+                ctx.fillStyle = '#e0e0e0'; // Light gray
+                // Note: roundRect requires recent canvas version or polyfill
+                if (ctx.roundRect) {
+                    ctx.beginPath();
+                    // Adjust X and Y to frame the text
+                    ctx.roundRect(currentX - 2, currentY + fontSize - boxYOffset, boxWidth, boxHeight, 8);
+                    ctx.fill();
+                }
+                else {
+                    // Fallback for older environments
+                    ctx.fillRect(currentX - 2, currentY + fontSize - boxYOffset, boxWidth, boxHeight);
+                }
+                // Draw Text on top
+                ctx.fillStyle = '#000000';
+                // Draw text with padding offset
+                ctx.fillText(segment.text, currentX + 4, currentY + fontSize);
+                // Advance X cursor including padding
+                currentX += boxWidth - 4;
+            }
+            else {
+                // --- DRAW NORMAL TEXT ---
+                ctx.font = normalFontStr;
+                ctx.fillStyle = 'black';
+                ctx.fillText(segment.text, currentX, currentY + fontSize);
+                // Advance X cursor based on pre-calculated width from wrapper
+                currentX += segment.width || ctx.measureText(segment.text).width;
+            }
+        }
+        // Move to next line
+        currentY += lineHeight;
+    }
+}
+function drawStatsFixed(ctx, files, fixedY) {
+    ctx.font = CONFIG.fonts.stats;
+    let currentY = fixedY;
+    const visibleFiles = files.slice(0, 5);
+    const hiddenCount = files.length - visibleFiles.length;
+    for (const file of visibleFiles) {
+        ctx.textAlign = 'left';
+        ctx.fillText(truncateMiddle(file.path, 28), CONFIG.padding, currentY);
+        const statsText = `+${file.additions} / -${file.deletions}`;
+        ctx.textAlign = 'right';
+        ctx.fillText(statsText, CONFIG.width - CONFIG.padding, currentY);
+        currentY += CONFIG.layout.footerLineHeight;
+    }
+    if (hiddenCount > 0) {
+        ctx.textAlign = 'center';
+        ctx.font = `italic 32px "Google Sans", sans-serif`;
+        ctx.fillText(`+ ${hiddenCount} more files...`, CONFIG.width / 2, currentY + 20);
+    }
+}

package/dist/pipeline.d.ts

@@ -0,0 +1,10 @@
+export interface ProcessOptions {
+    model?: string;
+    tone?: string;
+    printer?: string;
+}
+export declare function processSessionAndPrint(sessionId: string, options?: ProcessOptions): AsyncGenerator<{
+    activity: import("@google/jules-sdk").Activity;
+    summary: string;
+    labelPath: string;
+}, void, unknown>;

package/dist/pipeline.js

@@ -0,0 +1,87 @@
+import { jules } from '@google/jules-sdk';
+import { SessionSummarizer } from './summarizer.js';
+import { generateLabel } from './label-generator.js';
+import fs from 'fs';
+import path from 'path';
+import thermal from './print.js';
+export async function* processSessionAndPrint(sessionId, options = {}) {
+    // 1. Initialize Printer Hardware
+    const hw = thermal();
+    // Find printer: use specified name, or auto-discover
+    let printer = null;
+    if (options.printer) {
+        const printers = await hw.scan();
+        printer = printers.find(p => p.name === options.printer) || null;
+        if (!printer) {
+            console.warn(`⚠️ Printer "${options.printer}" not found. Labels will be saved to disk only.`);
+        }
+    }
+    else {
+        printer = await hw.find();
+    }
+    if (printer) {
+        console.log(`🖨️ Found printer: ${printer.name} (${printer.stat})`);
+        await hw.fix(printer.name);
+    }
+    else if (!options.printer) {
+        console.warn('⚠️ No printer found. Labels will be saved to disk only.');
+    }
+    const summarizer = new SessionSummarizer({
+        backend: 'cloud',
+        apiKey: process.env.GEMINI_API_KEY,
+        cloudModelName: options.model,
+        tone: options.tone,
+    });
+    let rollingSummary = "";
+    const session = jules.session(sessionId);
+    // Fetch session info to get the actual repo
+    const sessionInfo = await session.info();
+    const repo = sessionInfo.sourceContext?.source?.replace('sources/github/', '') || 'unknown/repo';
+    console.log(`📦 Repository: ${repo}`);
+    const outDir = path.resolve('output', sessionId);
+    if (!fs.existsSync(outDir))
+        fs.mkdirSync(outDir, { recursive: true });
+    let count = 0;
+    for await (const activity of session.stream()) {
+        console.log(`Processing Activity ${count + 1}: ${activity.type}`);
+        // 1. Generate Summary
+        rollingSummary = await summarizer.generateRollingSummary(rollingSummary, activity);
+        console.log(`> Summary: ${rollingSummary}`);
+        // 2. Extract Stats
+        const filesForLabel = summarizer.getLabelData(activity);
+        // 3. Generate Label Image
+        const labelData = {
+            repo,
+            sessionId: sessionId,
+            summary: rollingSummary,
+            files: filesForLabel
+        };
+        const buffer = await generateLabel(labelData);
+        // 4. Save to Disk (Backup)
+        const filename = `${count.toString().padStart(3, '0')}_${activity.type}.png`;
+        const filePath = path.join(outDir, filename);
+        fs.writeFileSync(filePath, buffer);
+        // 5. Print if printer available
+        if (printer) {
+            try {
+                console.log(`🖨️ Sending to ${printer.name}...`);
+                // Auto-heal the printer queue if it got paused
+                await hw.fix(printer.name);
+                const jobId = await hw.print(printer.name, buffer, {
+                    fit: true,
+                    media: 'w288h432'
+                });
+                console.log(`✅ Job ID: ${jobId}`);
+            }
+            catch (err) {
+                console.error(`❌ Print failed:`, err);
+            }
+        }
+        count++;
+        yield {
+            activity,
+            summary: rollingSummary,
+            labelPath: filePath
+        };
+    }
+}

package/dist/print.d.ts

@@ -0,0 +1,20 @@
+export type device = {
+    name: string;
+    usb: boolean;
+    def: boolean;
+    stat: string;
+};
+export type config = {
+    copies?: number;
+    media?: string;
+    fit?: boolean;
+    gray?: boolean;
+    flags?: Record<string, string>;
+};
+export default function thermal(): {
+    scan: () => Promise<device[]>;
+    find: () => Promise<device | null>;
+    fix: (name: string) => Promise<void>;
+    print: (target: string, input: Buffer | string, opts?: config) => Promise<string>;
+    watch: (signal: AbortSignal, delay?: number) => Promise<void>;
+};

package/dist/print.js

@@ -0,0 +1,100 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { writeFile, unlink, access, constants } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+const run = promisify(exec);
+// --- internals ---
+const file = async (buffer, fn) => {
+    const path = join(tmpdir(), `sticker-${randomUUID()}.png`);
+    await writeFile(path, buffer);
+    try {
+        return await fn(path);
+    }
+    finally {
+        unlink(path).catch(() => { });
+    }
+};
+const parse = (list, devices) => {
+    const lines = devices.split("\n");
+    const fallback = list.match(/system default destination: (.+)/)?.[1];
+    return list
+        .split("\n")
+        .map((line) => line.match(/printer (.+?) (.*)/))
+        .filter((m) => !!m)
+        .map(([, name, stat]) => {
+        const dev = lines.find((d) => d.includes(name));
+        return {
+            name,
+            stat,
+            usb: dev?.toLowerCase().includes("usb") ?? false,
+            def: name === fallback,
+        };
+    });
+};
+// --- module ---
+export default function thermal() {
+    const scan = async () => {
+        try {
+            const [ls, devs] = await Promise.all([
+                run("lpstat -p -d"),
+                run("lpstat -v"),
+            ]);
+            return parse(ls.stdout, devs.stdout);
+        }
+        catch {
+            return [];
+        }
+    };
+    const find = async () => {
+        const devs = await scan();
+        return (devs.find((d) => d.usb && d.def) ||
+            devs.find((d) => d.usb) ||
+            null);
+    };
+    const fix = async (name) => {
+        const { stdout } = await run(`lpstat -p "${name}"`);
+        const bad = ["disabled", "paused"].some((s) => stdout.toLowerCase().includes(s));
+        if (bad) {
+            await Promise.all([
+                run(`cupsenable "${name}"`),
+                run(`cupsaccept "${name}"`),
+            ]);
+            console.log(`✨ healed: ${name}`);
+        }
+    };
+    const print = async (target, input, opts = {}) => {
+        const task = async (path) => {
+            const args = [
+                `-d "${target}"`,
+                opts.copies && `-n ${opts.copies}`,
+                opts.media && `-o media=${opts.media}`,
+                opts.gray && "-o ColorModel=Gray",
+                opts.fit && "-o fit-to-page",
+                ...Object.entries(opts.flags || {}).map(([k, v]) => `-o ${k}=${v}`),
+                `"${path}"`,
+            ].filter(Boolean);
+            const { stdout } = await run(`lp ${args.join(" ")}`);
+            return stdout.match(/request id is .+-(\d+)/)?.[1] || "unknown";
+        };
+        if (Buffer.isBuffer(input)) {
+            return file(input, task);
+        }
+        await access(input, constants.R_OK);
+        return task(input);
+    };
+    const watch = async (signal, delay = 2000) => {
+        const tick = async () => {
+            if (signal.aborted)
+                return;
+            const devs = await scan();
+            const usb = devs.filter((d) => d.usb);
+            await Promise.all(usb.map((d) => fix(d.name)));
+            if (!signal.aborted)
+                setTimeout(tick, delay);
+        };
+        tick();
+    };
+    return { scan, find, fix, print, watch };
+}

package/dist/processor.d.ts

@@ -0,0 +1,21 @@
+import { type Activity } from '@google/jules-sdk';
+import { ChangeSetSummary } from './types.js';
+export interface ProcessedActivity {
+    activityId: string;
+    type: 'changeSet';
+    summary: ChangeSetSummary;
+    rawActivity: Activity;
+}
+export interface StreamMetricsOptions {
+    /**
+     * If true, keeps the stream open and listens for new activities from the network.
+     * If false, only reads existing history from the local cache and exits.
+     * @default true
+     */
+    live?: boolean;
+}
+/**
+ * Streams activities from a Jules session and yields parsed metrics
+ * whenever a ChangeSet is encountered.
+ */
+export declare function streamChangeMetrics(sessionId: string, options?: StreamMetricsOptions): AsyncGenerator<ProcessedActivity>;

package/dist/processor.js

@@ -0,0 +1,26 @@
+import { jules } from '@google/jules-sdk';
+import { analyzeChangeSet } from './analyzer.js';
+/**
+ * Streams activities from a Jules session and yields parsed metrics
+ * whenever a ChangeSet is encountered.
+ */
+export async function* streamChangeMetrics(sessionId, options = {}) {
+    const { live = true } = options;
+    const session = jules.session(sessionId);
+    // Choose between the infinite stream or the finite history
+    const activityStream = live ? session.stream() : session.history();
+    for await (const activity of activityStream) {
+        // We look for specific artifact types in the activity
+        const changeSetArtifact = activity.artifacts?.find(a => a.type === 'changeSet');
+        if (changeSetArtifact && changeSetArtifact.gitPatch?.unidiffPatch) {
+            const rawPatch = changeSetArtifact.gitPatch.unidiffPatch;
+            const summary = analyzeChangeSet(rawPatch);
+            yield {
+                activityId: activity.id,
+                type: 'changeSet',
+                summary,
+                rawActivity: activity
+            };
+        }
+    }
+}

package/dist/server.d.ts

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

package/dist/server.js

@@ -0,0 +1,57 @@
+import { Hono } from 'hono';
+import { serve } from '@hono/node-server';
+import { cors } from 'hono/cors';
+import { GoogleGenAI } from "@google/genai";
+import thermal from './print.js';
+const app = new Hono();
+const port = 3000;
+const hw = thermal();
+app.use('/*', cors());
+const controller = new AbortController();
+hw.watch(controller.signal);
+process.on('SIGINT', () => {
+    controller.abort();
+    process.exit();
+});
+const apiKey = process.env["GEMINI_API_KEY"];
+if (!apiKey) {
+    throw new Error("GEMINI_API_KEY environment variable is required");
+}
+const ai = new GoogleGenAI({ apiKey });
+const model = "imagen-4.0-generate-001";
+app.post('/api/generate', async (c) => {
+    const { prompt } = await c.req.json();
+    if (!prompt)
+        return c.json({ error: 'prompt required' }, 400);
+    try {
+        console.log(`🎨 dreaming: "${prompt}"`);
+        const res = await ai.models.generateImages({
+            model,
+            prompt: `A black and white kids coloring page. <image-description>${prompt}</image-description> ${prompt}`,
+            config: { numberOfImages: 1, aspectRatio: "9:16" },
+        });
+        const bytes = res.generatedImages?.[0]?.image?.imageBytes;
+        if (!bytes)
+            throw new Error('no bytes');
+        const buffer = Buffer.from(bytes, "base64");
+        const target = await hw.find();
+        if (target) {
+            console.log(`🖨️  routing: ${target.name}`);
+            hw.print(target.name, buffer, { fit: true })
+                .catch(err => console.warn('print error:', err));
+        }
+        else {
+            console.warn('⚠️  no usb found');
+        }
+        return new Response(new Uint8Array(buffer), {
+            headers: { 'Content-Type': 'image/png' },
+        });
+    }
+    catch (err) {
+        console.error('error:', err);
+        return c.json({ error: err instanceof Error ? err.message : 'unknown' }, 500);
+    }
+});
+serve({ fetch: app.fetch, port }, (info) => {
+    console.log(`🚀 server at http://localhost:${info.port}`);
+});

package/dist/summarizer.d.ts

@@ -0,0 +1,32 @@
+import { type Activity } from '@google/jules-sdk';
+export type TonePreset = 'professional' | 'pirate' | 'shakespearean' | 'excited' | 'haiku' | 'noir';
+export interface SummarizerConfig {
+    backend?: 'cloud' | 'local';
+    apiKey?: string;
+    localModelName?: string;
+    cloudModelName?: string;
+    tone?: string;
+    tier?: 'free' | 'tier1';
+}
+export declare class SessionSummarizer {
+    private backend;
+    private localModelName;
+    private toneModifier;
+    private genAI;
+    private genModel;
+    private ollama;
+    private limiter;
+    constructor(config?: SummarizerConfig);
+    generateRollingSummary(previousState: string, currentActivity: Activity): Promise<string>;
+    private getCodePrompt;
+    private getPlanningPrompt;
+    getLabelData(activity: Activity): {
+        path: string;
+        additions: number;
+        deletions: number;
+    }[];
+    private executeRequest;
+    private simplifyActivity;
+    private buildSmartContext;
+    private extractHunkHeaders;
+}

package/dist/summarizer.js

@@ -0,0 +1,241 @@
+import { GoogleGenAI } from '@google/genai';
+import { Ollama } from 'ollama';
+import parseDiff from 'parse-diff';
+import micromatch from 'micromatch';
+import { encode } from 'gpt-tokenizer';
+import Bottleneck from 'bottleneck';
+// --- Configuration Constants ---
+const CLOUD_MODEL_NAME = 'gemini-2.5-flash-lite';
+const LOCAL_MODEL_DEFAULT = 'gemma3:4b';
+const TOKEN_LIMIT_PER_FILE = 2000;
+const MAX_TOTAL_TOKENS = 6000;
+const IGNORE_PATTERNS = [
+    '**/package-lock.json',
+    '**/yarn.lock',
+    '**/*.map',
+    '**/dist/**',
+    '**/*.min.js',
+    '**/*.d.ts'
+];
+const TONE_MODIFIERS = {
+    professional: '',
+    pirate: 'Write in the style of a pirate. Use nautical terms and pirate slang like "arr", "matey", "ye", "be", etc.',
+    shakespearean: 'Write in Shakespearean English with dramatic flair. Use "doth", "hark", "forsooth", "verily", etc.',
+    excited: 'Write with EXTREME enthusiasm!!! Use exclamation marks and emojis like 🎉🚀✨💥!',
+    haiku: 'Format your response as a haiku (5-7-5 syllable structure). Be poetic and zen.',
+    noir: 'Write in the style of a 1940s noir detective narration. Dark, moody, metaphorical.',
+};
+/** Resolves a tone string to its modifier. Accepts preset names or custom instructions. */
+function resolveToneModifier(tone) {
+    if (!tone || tone === 'professional')
+        return '';
+    if (tone in TONE_MODIFIERS)
+        return TONE_MODIFIERS[tone];
+    // Treat as custom tone instruction
+    return tone;
+}
+export class SessionSummarizer {
+    backend;
+    localModelName;
+    toneModifier;
+    genAI = null;
+    genModel = null;
+    ollama = null;
+    limiter;
+    constructor(config = {}) {
+        this.backend = config.backend || 'local';
+        this.localModelName = config.localModelName || LOCAL_MODEL_DEFAULT;
+        this.toneModifier = resolveToneModifier(config.tone);
+        if (this.backend === 'cloud') {
+            const key = config.apiKey || process.env.GEMINI_API_KEY;
+            if (!key)
+                throw new Error('Missing GEMINI_API_KEY for cloud backend');
+            this.genAI = new GoogleGenAI({ apiKey: key });
+            this.genModel = config.cloudModelName || CLOUD_MODEL_NAME;
+            const isTier1 = config.tier === 'tier1';
+            this.limiter = new Bottleneck({
+                minTime: isTier1 ? 20 : 4000,
+                maxConcurrent: isTier1 ? 5 : 1
+            });
+        }
+        else {
+            this.ollama = new Ollama();
+            this.limiter = new Bottleneck({ maxConcurrent: 1 });
+        }
+    }
+    async generateRollingSummary(previousState, currentActivity) {
+        const activityContext = this.simplifyActivity(currentActivity);
+        // DECISION LOGIC: Coding (Diffs) vs. Non-Coding (Plans/Messages)
+        const isCodeTask = !!activityContext.context;
+        if (isCodeTask) {
+            return this.executeRequest(this.getCodePrompt(activityContext));
+        }
+        else {
+            return this.executeRequest(this.getPlanningPrompt(activityContext));
+        }
+    }
+    // --- PROMPT 1: THE ACTIVE CODER (For Diffs) ---
+    getCodePrompt(context) {
+        const toneInstruction = this.toneModifier ? `\n      4. TONE: ${this.toneModifier}` : '';
+        return `
+      ROLE: You are the AI Developer.
+      TASK: Report the technical action taken.
+
+      INPUT DATA GUIDANCE:
+      - 'status': 'truncated_large_file' -> Infer changes from 'affectedScopes'.
+      - 'status': 'included' -> Read 'diff' for logic details.
+      
+      NEW ACTIVITY:
+      ${JSON.stringify(context)}
+
+      INSTRUCTIONS:
+      1. STYLE: Direct Technical Statement. Start with the Verb.
+         - YES: "Refactoring SessionClient to support new handshake."
+         - NO: "I am updating..." or "Updating..." (Passive)
+      2. FORMATTING: Wrap ALL filenames/classes in backticks (\`).
+      3. LENGTH: 110-150 chars.${toneInstruction}
+
+      OUTPUT:
+    `;
+    }
+    // --- PROMPT 2: THE OBJECTIVE REPORTER (For Plans/Messages) ---
+    getPlanningPrompt(context) {
+        const toneInstruction = this.toneModifier ? `\n      5. TONE: ${this.toneModifier}` : '';
+        return `
+      ROLE: You are a Project Logger.
+      TASK: Summarize the event based on the JSON below.
+
+      NEW ACTIVITY:
+      ${JSON.stringify(context)}
+
+      INSTRUCTIONS:
+      1. STYLE: Objective & Natural. 
+         - BAD: "Hey, I made a plan..." (Too chatty)
+         - BAD: "Strategizing the execution..." (Too corporate)
+         - GOOD: "Generated a plan to update the SessionClient logic."
+         - GOOD: "Plan approved. Starting implementation."
+         - GOOD: "User requested a format check."
+
+      2. BAN LIST: Do NOT start sentences with "Hey", "Okay", "So", "Alright", "Well".
+      
+      3. CONTENT: 
+         - Use the 'title' or 'description' fields from the input.
+         - Summarize the specific goal (e.g. "update SessionClient").
+
+      4. LENGTH: 110-150 chars.${toneInstruction}
+
+      OUTPUT:
+    `;
+    }
+    // ... (getLabelData, executeRequest, etc. remain exactly the same) ...
+    getLabelData(activity) {
+        const changeSetArtifact = activity.artifacts?.find(a => a.type === 'changeSet');
+        if (!changeSetArtifact || changeSetArtifact.type !== 'changeSet' || !changeSetArtifact.gitPatch)
+            return [];
+        const files = parseDiff(changeSetArtifact.gitPatch.unidiffPatch);
+        return files
+            .filter(f => !micromatch.isMatch(f.to || f.from || '', IGNORE_PATTERNS))
+            .map(file => ({
+            path: file.to || file.from || 'unknown',
+            additions: file.additions,
+            deletions: file.deletions
+        }));
+    }
+    async executeRequest(prompt, attempt = 1) {
+        return this.limiter.schedule(async () => {
+            try {
+                let text = '';
+                if (this.backend === 'cloud' && this.genAI) {
+                    const result = await this.genAI.models.generateContent({
+                        model: this.genModel,
+                        contents: prompt,
+                    });
+                    text = result.text || '';
+                }
+                else if (this.backend === 'local' && this.ollama) {
+                    const response = await this.ollama.chat({
+                        model: this.localModelName,
+                        messages: [{ role: 'user', content: prompt }],
+                        options: { temperature: 0.2, num_ctx: 8192, num_predict: 128 }
+                    });
+                    text = response.message.content;
+                }
+                return text.replace(/```/g, '').replace(/[\n\r]/g, ' ').replace(/\s+/g, ' ').trim();
+            }
+            catch (error) {
+                const isRetryable = error.status === 429 || error.message?.includes('429') ||
+                    error.status === 503 || error.message?.includes('503') ||
+                    error.message?.includes('overloaded');
+                if (this.backend === 'cloud' && isRetryable && attempt < 5) {
+                    const backoffMs = Math.min(2000 * Math.pow(2, attempt - 1), 60000);
+                    console.log(`[Summarizer] Retrying in ${backoffMs / 1000}s (attempt ${attempt}/5)...`);
+                    await new Promise(r => setTimeout(r, backoffMs));
+                    return this.executeRequest(prompt, attempt + 1);
+                }
+                console.error(`[Summarizer] Error:`, error.message);
+                throw error;
+            }
+        });
+    }
+    // --- UPDATED SIMPLIFY ACTIVITY ---
+    simplifyActivity(activity) {
+        const base = { type: activity.type, originator: activity.originator };
+        // 1. Code Changes
+        const changeSet = activity.artifacts?.find(a => a.type === 'changeSet');
+        if (changeSet && changeSet.type === 'changeSet' && changeSet.gitPatch) {
+            return {
+                ...base,
+                context: this.buildSmartContext(changeSet.gitPatch.unidiffPatch),
+                commitMessage: changeSet.gitPatch.suggestedCommitMessage
+            };
+        }
+        // 2. Planning - EXTRACT ACTUAL TEXT
+        if (activity.type === 'planGenerated') {
+            // Deep extraction to find meaningful text
+            const plan = activity.planGenerated?.plan || activity.plan;
+            const firstStep = plan?.steps?.[0]?.title;
+            const activityTitle = activity.title;
+            // Priority: Activity Title -> First Step Title -> Generic fallback
+            const description = activityTitle || firstStep || 'Plan generated with no details.';
+            return { ...base, description };
+        }
+        if (activity.type === 'planApproved') {
+            return { ...base, description: 'User approved the plan.' };
+        }
+        // 3. Messages
+        if (activity.type === 'agentMessaged' || activity.type === 'userMessaged') {
+            return { ...base, message: activity.message };
+        }
+        // 4. Progress
+        if (activity.type === 'progressUpdated') {
+            return { ...base, description: activity.title };
+        }
+        return base;
+    }
+    buildSmartContext(rawDiff) {
+        const files = parseDiff(rawDiff);
+        let currentTokenCount = 0;
+        return files.map(file => {
+            const filePath = file.to || file.from || 'unknown';
+            if (micromatch.isMatch(filePath, IGNORE_PATTERNS)) {
+                return { file: filePath, status: 'ignored_artifact', changes: `+${file.additions}/-${file.deletions}` };
+            }
+            const fileDiffString = file.chunks.map(c => c.content).join('\n');
+            const fileTokens = encode(fileDiffString).length;
+            if (currentTokenCount + fileTokens > MAX_TOTAL_TOKENS) {
+                return { file: filePath, status: 'truncated_budget_exceeded', summary: `Modified ${file.additions} lines`, affectedMethods: this.extractHunkHeaders(file.chunks) };
+            }
+            if (fileTokens > TOKEN_LIMIT_PER_FILE) {
+                return { file: filePath, status: 'truncated_large_file', summary: `Large refactor (+${file.additions}/-${file.deletions})`, affectedScopes: this.extractHunkHeaders(file.chunks) };
+            }
+            currentTokenCount += fileTokens;
+            return { file: filePath, status: 'included', diff: fileDiffString };
+        });
+    }
+    extractHunkHeaders(chunks) {
+        return chunks.map(chunk => {
+            const headerMatch = chunk.content.match(/@@.*?@@\s*(.*)/);
+            return headerMatch ? headerMatch[1].trim() : null;
+        }).filter(Boolean).slice(0, 5);
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Represents the statistical impact of changes on a specific file.
+ */
+export interface FileImpact {
+    path: string;
+    additions: number;
+    deletions: number;
+    totalChanges: number;
+}
+/**
+ * A comprehensive report of a Git Patch / ChangeSet.
+ */
+export interface ChangeSetSummary {
+    files: FileImpact[];
+    totalFiles: number;
+    totalInsertions: number;
+    totalDeletions: number;
+    /**
+     * Formatted string suitable for footer display.
+     * e.g., "3 files changed, 48 insertions(+), 14 deletions(-)"
+     */
+    summaryString: string;
+}

package/dist/types.js

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

package/dist/utils.d.ts

@@ -0,0 +1,17 @@
+import { CanvasRenderingContext2D } from '@napi-rs/canvas';
+export declare function calculateWrappedLines(ctx: CanvasRenderingContext2D, text: string, maxWidth: number): string[];
+export declare function truncateMiddle(text: string, maxLength: number): string;
+export interface TextSegment {
+    text: string;
+    isCode: boolean;
+    width?: number;
+}
+/**
+ * Splits string by backticks into normal and code segments.
+ * e.g., "foo `bar` baz" -> [{text:"foo ", isCode:false}, {text:"bar", isCode:true}, {text:" baz", isCode:false}]
+ */
+export declare function parseMarkdownSegments(text: string): TextSegment[];
+/**
+ * Advanced wrapper that handles mixed-style segments AND long-word breaking.
+ */
+export declare function calculateWrappedSegments(ctx: any, segments: TextSegment[], maxWidth: number, normalFont: string, codeFont: string): TextSegment[][];

package/dist/utils.js

@@ -0,0 +1,138 @@
+// Helper to wrap text
+export function calculateWrappedLines(ctx, text, maxWidth) {
+    const words = text.split(' ');
+    const lines = [];
+    let currentLine = words[0];
+    for (let i = 1; i < words.length; i++) {
+        const word = words[i];
+        const width = ctx.measureText(currentLine + " " + word).width;
+        if (width < maxWidth) {
+            currentLine += " " + word;
+        }
+        else {
+            lines.push(currentLine);
+            currentLine = word;
+        }
+    }
+    lines.push(currentLine);
+    return lines;
+}
+// Helper to truncate middle
+export function truncateMiddle(text, maxLength) {
+    if (text.length <= maxLength)
+        return text;
+    const ellipsis = '...';
+    const charsToShow = maxLength - ellipsis.length;
+    const frontChars = Math.ceil(charsToShow / 2);
+    const backChars = Math.floor(charsToShow / 2);
+    return text.substring(0, frontChars) + ellipsis + text.substring(text.length - backChars);
+}
+/**
+ * Splits string by backticks into normal and code segments.
+ * e.g., "foo `bar` baz" -> [{text:"foo ", isCode:false}, {text:"bar", isCode:true}, {text:" baz", isCode:false}]
+ */
+export function parseMarkdownSegments(text) {
+    // Split by backtick.
+    // Even indices are normal text, Odd indices are code.
+    const rawSegments = text.split('`');
+    const segments = [];
+    rawSegments.forEach((segmentText, index) => {
+        if (segmentText.length === 0)
+            return; // Skip empty splits
+        segments.push({
+            text: segmentText,
+            isCode: index % 2 !== 0 // Odd index means it was inside backticks
+        });
+    });
+    return segments;
+}
+/**
+ * Advanced wrapper that handles mixed-style segments AND long-word breaking.
+ */
+export function calculateWrappedSegments(ctx, segments, maxWidth, normalFont, codeFont) {
+    const lines = [];
+    let currentLine = [];
+    let currentLineWidth = 0;
+    for (const segment of segments) {
+        // 1. Set font for measurement
+        ctx.font = segment.isCode ? codeFont : normalFont;
+        // 2. Measure the raw text
+        const padding = segment.isCode ? 8 : 0; // 4px padding on each side for code
+        const segmentWidth = ctx.measureText(segment.text).width + padding;
+        // 3. Logic for Code Blocks vs Normal Text
+        if (segment.isCode) {
+            // CASE A: Code block fits on current line
+            if (currentLineWidth + segmentWidth <= maxWidth) {
+                currentLine.push({ ...segment, width: segmentWidth });
+                currentLineWidth += segmentWidth;
+            }
+            // CASE B: Code block is huge (wider than maxWidth) -> Force Break
+            else if (segmentWidth > maxWidth) {
+                // 1. Flush current line if it has content
+                if (currentLine.length > 0) {
+                    lines.push(currentLine);
+                    currentLine = [];
+                    currentLineWidth = 0;
+                }
+                // 2. Break the long string into chunks
+                const chars = segment.text.split('');
+                let chunk = '';
+                for (const char of chars) {
+                    const testChunk = chunk + char;
+                    const testWidth = ctx.measureText(testChunk).width + padding;
+                    if (testWidth > maxWidth) {
+                        // Flush chunk to line
+                        lines.push([{ text: chunk, isCode: true, width: ctx.measureText(chunk).width + padding }]);
+                        chunk = char; // Start new chunk
+                    }
+                    else {
+                        chunk = testChunk;
+                    }
+                }
+                // Add final chunk
+                if (chunk.length > 0) {
+                    const width = ctx.measureText(chunk).width + padding;
+                    currentLine.push({ text: chunk, isCode: true, width });
+                    currentLineWidth += width;
+                }
+            }
+            // CASE C: Code block fits on NEXT line
+            else {
+                lines.push(currentLine);
+                currentLine = [];
+                currentLineWidth = 0;
+                currentLine.push({ ...segment, width: segmentWidth });
+                currentLineWidth += segmentWidth;
+            }
+        }
+        else {
+            // Normal Text Logic (Word Wrapping)
+            // This handles the "orphaned period" issue by keeping punctuation with the preceding word if possible
+            // or wrapping correctly.
+            const words = segment.text.split(/(\s+)/); // Split keeping delimiters to preserve spaces
+            for (const word of words) {
+                if (word.length === 0)
+                    continue;
+                const wordWidth = ctx.measureText(word).width;
+                if (currentLineWidth + wordWidth <= maxWidth) {
+                    currentLine.push({ text: word, isCode: false, width: wordWidth });
+                    currentLineWidth += wordWidth;
+                }
+                else {
+                    // Start new line
+                    lines.push(currentLine);
+                    currentLine = [];
+                    currentLineWidth = 0;
+                    // If a single word is massive (unlikely in normal text, but possible), clip it
+                    // For now, assume normal words fit on a line.
+                    currentLine.push({ text: word, isCode: false, width: wordWidth });
+                    currentLineWidth += wordWidth;
+                }
+            }
+        }
+    }
+    // Flush remaining
+    if (currentLine.length > 0)
+        lines.push(currentLine);
+    return lines;
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "jules-ink",
+  "version": "0.0.2",
+  "description": "Print physical labels of your AI coding sessions with Jules",
+  "type": "module",
+  "main": "./dist/cli.js",
+  "types": "./dist/cli.d.ts",
+  "bin": {
+    "jules-ink": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "assets"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "start": "tsx src/index.ts",
+    "test": "vitest",
+    "test:smoke": "vitest run tests/cli.smoke.test.ts",
+    "gen:assets": "tsx scripts/create-base-template.ts"
+  },
+  "keywords": [
+    "jules",
+    "ai",
+    "coding",
+    "labels",
+    "thermal-printer",
+    "cli"
+  ],
+  "author": "David East",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/davideast/jules.ink.git"
+  },
+  "dependencies": {
+    "@google/genai": "^1.39.0",
+    "@google/jules-sdk": "^0.0.4",
+    "@napi-rs/canvas": "^0.1.44",
+    "bottleneck": "^2.19.5",
+    "commander": "^14.0.3",
+    "dotenv": "^16.4.5",
+    "gpt-tokenizer": "^3.4.0",
+    "micromatch": "^4.0.8",
+    "ollama": "^0.6.3",
+    "parse-diff": "^0.11.1"
+  },
+  "devDependencies": {
+    "@hono/node-server": "^1.19.6",
+    "@types/micromatch": "^4.0.10",
+    "@types/node": "^20.11.20",
+    "hono": "^4.10.6",
+    "tsx": "^4.7.1",
+    "typescript": "^5.3.3",
+    "vitest": "^1.3.1"
+  }
+}