jules-ink 0.0.3 → 0.2.0

package/dist/cli.js

@@ -1,6 +1,10 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import { processSessionAndPrint } from './pipeline.js';
+import { generateLabel } from './label-generator.js';
+import thermal from './print.js';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
 const program = new Command();
 program
     .name('jules-ink')
@@ -18,24 +22,157 @@ program
     const sessionId = options.session;
     const model = options.model;
     const tone = options.tone;
-    const printer = options.printer;
+    const printerName = options.printer;
     const outputDir = options.output;
     console.log(`\n🚀 Starting Label Pipeline for Session: ${sessionId}`);
     console.log(`📦 Using model: ${model}`);
     console.log(`🎭 Tone: ${tone}`);
     console.log(`===================================================\n`);
+    // --- CLI-only: Printer discovery ---
+    const hw = thermal();
+    let printer = null;
+    if (printerName) {
+        const printers = await hw.scan();
+        printer = printers.find(p => p.name === printerName) || null;
+        if (!printer) {
+            console.warn(`⚠️ Printer "${printerName}" 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 (!printerName) {
+        console.warn('⚠️ No printer found. Labels will be saved to disk only.');
+    }
+    // --- CLI-only: Output directory ---
+    const baseDir = outputDir || process.env.JULES_INK_OUTPUT_DIR || 'output';
+    const outDir = path.resolve(baseDir, sessionId);
+    if (!fs.existsSync(outDir))
+        fs.mkdirSync(outDir, { recursive: true });
+    let repo = 'unknown/repo';
+    const { streamSession } = await import('./session-stream.js');
     try {
-        const generator = processSessionAndPrint(sessionId, { model, tone, printer, outputDir });
-        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`);
+        for await (const event of streamSession(sessionId, { model, tone })) {
+            if (event.type === 'session:info') {
+                repo = event.repo;
+                console.log(`📦 Repository: ${repo}`);
+                continue;
+            }
+            if (event.type === 'session:error') {
+                console.error(`❌ Error: ${event.error}`);
+                continue;
+            }
+            if (event.type === 'session:complete') {
+                console.log(`\n✅ Session ${sessionId} processing complete. ${event.totalActivities} activities.`);
+                continue;
+            }
+            if (event.type === 'activity:processed') {
+                console.log(`Processing Activity ${event.index + 1}: ${event.activityType}`);
+                console.log(`> Summary: ${event.summary}`);
+                // Generate label image
+                const labelData = {
+                    repo,
+                    sessionId,
+                    summary: event.summary,
+                    files: event.files,
+                };
+                const buffer = await generateLabel(labelData);
+                // Save to disk
+                const filename = `${event.index.toString().padStart(3, '0')}_${event.activityType}.png`;
+                const filePath = path.join(outDir, filename);
+                fs.writeFileSync(filePath, buffer);
+                // Print if printer available
+                if (printer) {
+                    try {
+                        console.log(`🖨️ Sending to ${printer.name}...`);
+                        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);
+                    }
+                }
+                console.log(`✓ [${event.activityType}] Processed`);
+                console.log(`  └─ Summary: "${event.summary.substring(0, 60)}..."`);
+                console.log(`  └─ Label:   ${filePath}\n`);
+            }
         }
-        console.log(`✅ Session ${sessionId} processing complete.`);
     }
     catch (error) {
         console.error('\n❌ Fatal Error processing session:', error);
         process.exit(1);
     }
 });
-program.parse();
+program
+    .command('ui')
+    .description('Start the UI and API server')
+    .option('--api-port <port>', 'API server port', '3000')
+    .option('--ui-port <port>', 'UI server port', '4321')
+    .action(async (options) => {
+    const apiPort = parseInt(options.apiPort);
+    const uiPort = parseInt(options.uiPort);
+    const pkgRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+    const uiSrcDir = path.join(pkgRoot, 'ui', 'src');
+    const uiDistDir = path.join(pkgRoot, 'ui', 'dist');
+    const devMode = fs.existsSync(uiSrcDir);
+    if (!devMode && !fs.existsSync(uiDistDir)) {
+        console.error('Neither ui/src/ nor ui/dist/ found. Is the package installed correctly?');
+        process.exit(1);
+    }
+    // Set JULES_INK_ROOT so Astro API routes can find .env and .jules/
+    const rootDir = devMode ? pkgRoot : process.cwd();
+    process.env.JULES_INK_ROOT = rootDir;
+    // Load .env from the root directory
+    const { config } = await import('dotenv');
+    config({ path: path.join(rootDir, '.env') });
+    // Start API server
+    const { serve } = await import('@hono/node-server');
+    const { default: app } = await import('./server.js');
+    const server = serve({ fetch: app.fetch, port: apiPort }, (info) => {
+        console.log(`API server running at http://localhost:${info.port}`);
+    });
+    if (devMode) {
+        // Dev mode: Astro dev server with HMR
+        const { dev } = await import('astro');
+        const devServer = await dev({ root: path.join(pkgRoot, 'ui'), server: { port: uiPort } });
+        const cleanup = async () => {
+            await devServer.stop();
+            server.close();
+            process.exit();
+        };
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+    }
+    else {
+        // Production mode: serve pre-built Astro output
+        // Prevent @astrojs/node from auto-starting its own listener
+        process.env.ASTRO_NODE_AUTOSTART = 'disabled';
+        const entryPath = path.join(uiDistDir, 'server', 'entry.mjs');
+        const { handler } = await import(entryPath);
+        const http = await import('node:http');
+        const uiServer = http.createServer(handler);
+        uiServer.listen(uiPort, () => {
+            console.log(`UI server running at http://localhost:${uiPort}`);
+        });
+        const cleanup = () => {
+            uiServer.close();
+            server.close();
+            process.exit();
+        };
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+    }
+});
+// Only parse when run directly as the CLI entry point
+const __filename = fileURLToPath(import.meta.url);
+if (process.argv[1] === __filename || process.argv[1]?.endsWith('/jules-ink')) {
+    program.parse();
+}

package/dist/example.js

@@ -0,0 +1,27 @@
+async function main() {
+    import thermal from './print.js';
+    const hw = thermal();
+    const printers = await hw.scan();
+    console.log(printers);
+    // Logs:
+    // [
+    //   {
+    //     name: 'Brother_MFC_J1205W',
+    //     stat: 'disabled since Sun Nov 23 18:51:43 2025 -',
+    //     usb: true,
+    //     def: false
+    //   },
+    //   {
+    //     name: 'PM-241-BT',
+    //     stat: 'is idle.  enabled since Mon Nov 10 15:45:15 2025',
+    //     usb: true,
+    //     def: true
+    //   }
+    // ]
+    // const sessionId = '7058525030495993685';
+    // for await (const result of processSessionAndPrint(sessionId)) {
+    //   console.log(result);
+    // }
+}
+main();
+export {};

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { streamSession } from './session-stream.js';
+export type { SessionEvent, SessionStreamOptions } from './session-stream.js';
+export { SessionSummarizer } from './summarizer.js';
+export type { SummarizerConfig, TonePreset } from './summarizer.js';
+export { analyzeChangeSet } from './analyzer.js';
+export type { FileImpact, ChangeSetSummary } from './types.js';
+export { generateLabel } from './label-generator.js';
+export type { LabelData, FileStat } from './label-generator.js';
+export { default as thermal } from './print.js';
+export type { device, config } from './print.js';
+export { TONE_PRESETS } from './tone-presets.js';
+export { loadTones, saveTone, deleteTone } from './tones.js';
+export type { Tone } from './tones.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+// Library barrel export — the public API of jules-ink
+export { streamSession } from './session-stream.js';
+export { SessionSummarizer } from './summarizer.js';
+export { analyzeChangeSet } from './analyzer.js';
+export { generateLabel } from './label-generator.js';
+export { default as thermal } from './print.js';
+export { TONE_PRESETS } from './tone-presets.js';
+export { loadTones, saveTone, deleteTone } from './tones.js';

package/dist/label-generator.js

@@ -4,30 +4,48 @@ import fs from 'fs';
 import { truncateMiddle } from './utils.js';
 import { parseMarkdownSegments, calculateWrappedSegments } from './utils.js';
 // --- Path Resolution ---
+// Resolve assets from the project root. We try import.meta.url first (works
+// when running directly from dist/), then fall back to process.cwd() which
+// handles the Vite-bundled SSR case where import.meta.url points at the
+// Astro output chunk instead of the original dist/ file.
 import { fileURLToPath } from 'url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-// assets are in ../assets relative to dist/label-generator.js
-const ASSETS_DIR = path.join(__dirname, '..', 'assets');
+function resolveAssetsDir() {
+    // Try 1: relative to this file (dist/label-generator.js → ../assets)
+    try {
+        const dir = path.dirname(fileURLToPath(import.meta.url));
+        const candidate = path.join(dir, '..', 'assets');
+        if (fs.existsSync(path.join(candidate, 'fonts')))
+            return candidate;
+    }
+    catch { /* import.meta.url might not resolve usefully */ }
+    // Try 2: relative to cwd (project root → assets)
+    const cwdCandidate = path.join(process.cwd(), 'assets');
+    if (fs.existsSync(path.join(cwdCandidate, 'fonts')))
+        return cwdCandidate;
+    // Fallback: return the cwd candidate anyway; registerLocalFont will just skip missing files
+    return cwdCandidate;
+}
+const ASSETS_DIR = resolveAssetsDir();
 const FONT_DIR = path.join(ASSETS_DIR, '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"';
+// Use unique family names to avoid @napi-rs/canvas font-cache poisoning:
+// once a name resolves to a fallback, it's permanently cached even after
+// the real font is registered. Unique names guarantee first-resolution
+// always finds the registered font.
+registerLocalFont('Inter-Medium.ttf', 'LabelSans');
+registerLocalFont('JetBrainsMono-Regular.ttf', 'LabelMono');
 // --- 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}`,
+        header: '36px "LabelMono", monospace',
+        stats: '42px "LabelMono", monospace',
     },
     layout: {
         headerY: 120,
@@ -44,12 +62,30 @@ const CONFIG = {
         footerLineHeight: 65
     }
 };
+let templatePromise = null;
+async function getTemplate() {
+    if (templatePromise)
+        return templatePromise;
+    templatePromise = (async () => {
+        const templatePath = path.join(ASSETS_DIR, 'template.png');
+        if (fs.existsSync(templatePath)) {
+            try {
+                return await loadImage(templatePath);
+            }
+            catch (error) {
+                console.error('Failed to load template image:', error);
+                return null;
+            }
+        }
+        return null;
+    })();
+    return templatePromise;
+}
 export async function generateLabel(data) {
     const canvas = createCanvas(CONFIG.width, CONFIG.height);
     const ctx = canvas.getContext('2d');
-    const templatePath = path.join(ASSETS_DIR, 'template.png');
-    if (fs.existsSync(templatePath)) {
-        const template = await loadImage(templatePath);
+    const template = await getTemplate();
+    if (template) {
         ctx.drawImage(template, 0, 0, CONFIG.width, CONFIG.height);
     }
     else {
@@ -80,10 +116,10 @@ function drawHeader(ctx, repo, sessionId) {
     const sessionWidth = ctx.measureText(sessionId).width;
     const maxRepoWidth = width - (padding * 2) - sessionWidth - 40;
     let fontSize = 36;
-    ctx.font = `${fontSize}px "Google Sans Mono", monospace`;
+    ctx.font = `${fontSize}px "LabelMono", monospace`;
     while (ctx.measureText(repo).width > maxRepoWidth && fontSize > 20) {
         fontSize -= 2;
-        ctx.font = `${fontSize}px "Google Sans Mono", monospace`;
+        ctx.font = `${fontSize}px "LabelMono", monospace`;
     }
     ctx.textAlign = 'left';
     ctx.fillText(repo, padding, CONFIG.layout.headerY);
@@ -99,16 +135,13 @@ function drawBodyAnchored(ctx, text, fixedY, maxHeight) {
     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}`;
+        normalFontStr = `${fontSize}px "LabelSans"`;
         // Use slightly smaller font for mono so it doesn't overpower the text
-        codeFontStr = `normal ${fontSize - 4}px "Google Sans Mono"${EMOJI_FALLBACK}`;
+        codeFontStr = `${fontSize - 4}px "LabelMono", monospace`;
         // Use new wrapper that understands mixed fonts
         wrappedLines = calculateWrappedSegments(ctx, allSegments, maxWidth, normalFontStr, codeFontStr);
         lineHeight = Math.floor(fontSize * lineHeightMultiplier);
@@ -189,7 +222,7 @@ function drawStatsFixed(ctx, files, fixedY) {
     }
     if (hiddenCount > 0) {
         ctx.textAlign = 'center';
-        ctx.font = `italic 32px "Google Sans", sans-serif`;
+        ctx.font = `italic 32px "LabelSans", sans-serif`;
         ctx.fillText(`+ ${hiddenCount} more files...`, CONFIG.width / 2, currentY + 20);
     }
 }

package/dist/pipeline.d.ts

@@ -1,9 +1,11 @@
+/** @deprecated Use `SessionStreamOptions` from `./session-stream.js` instead. */
 export interface ProcessOptions {
     model?: string;
     tone?: string;
     printer?: string;
     outputDir?: string;
 }
+/** @deprecated Use `streamSession` from `./session-stream.js` instead. */
 export declare function processSessionAndPrint(sessionId: string, options?: ProcessOptions): AsyncGenerator<{
     activity: import("@google/jules-sdk").Activity;
     summary: string;

package/dist/pipeline.js

@@ -1,9 +1,14 @@
-import { jules } from '@google/jules-sdk';
+/**
+ * @deprecated Use `streamSession` from `./session-stream.js` instead.
+ * This module couples streaming, file I/O, and printing in a single generator.
+ * The new `streamSession` yields portable typed events without I/O side effects.
+ */
 import { SessionSummarizer } from './summarizer.js';
 import { generateLabel } from './label-generator.js';
 import fs from 'fs';
 import path from 'path';
 import thermal from './print.js';
+/** @deprecated Use `streamSession` from `./session-stream.js` instead. */
 export async function* processSessionAndPrint(sessionId, options = {}) {
     // 1. Initialize Printer Hardware
     const hw = thermal();
@@ -26,6 +31,8 @@ export async function* processSessionAndPrint(sessionId, options = {}) {
     else if (!options.printer) {
         console.warn('⚠️ No printer found. Labels will be saved to disk only.');
     }
+    const { connect } = await import('@google/jules-sdk');
+    const jules = connect();
     const summarizer = new SessionSummarizer({
         backend: 'cloud',
         apiKey: process.env.GEMINI_API_KEY,

package/dist/processor.d.ts

@@ -1,4 +1,4 @@
-import { type Activity } from '@google/jules-sdk';
+import type { Activity } from '@google/jules-sdk';
 import { ChangeSetSummary } from './types.js';
 export interface ProcessedActivity {
     activityId: string;

package/dist/processor.js

@@ -1,4 +1,3 @@
-import { jules } from '@google/jules-sdk';
 import { analyzeChangeSet } from './analyzer.js';
 /**
  * Streams activities from a Jules session and yields parsed metrics
@@ -6,6 +5,8 @@ import { analyzeChangeSet } from './analyzer.js';
  */
 export async function* streamChangeMetrics(sessionId, options = {}) {
     const { live = true } = options;
+    const { connect } = await import('@google/jules-sdk');
+    const jules = connect();
     const session = jules.session(sessionId);
     // Choose between the infinite stream or the finite history
     const activityStream = live ? session.stream() : session.history();

package/dist/server.d.ts

@@ -1 +1,3 @@
-export {};
+import { Hono } from 'hono';
+declare const app: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default app;

package/dist/server.js

@@ -3,23 +3,23 @@ import { serve } from '@hono/node-server';
 import { cors } from 'hono/cors';
 import { GoogleGenAI } from "@google/genai";
 import thermal from './print.js';
+import { fileURLToPath } from 'url';
 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 allowedOrigins = process.env.ALLOWED_ORIGINS
+    ? process.env.ALLOWED_ORIGINS.split(',').map(o => o.trim())
+    : ['http://localhost:4321', 'http://localhost:3000'];
+app.use('/*', cors({
+    origin: allowedOrigins,
+}));
 const model = "imagen-4.0-generate-001";
 app.post('/api/generate', async (c) => {
+    const apiKey = process.env["GEMINI_API_KEY"];
+    if (!apiKey) {
+        return c.json({ error: "GEMINI_API_KEY environment variable is required" }, 500);
+    }
+    const ai = new GoogleGenAI({ apiKey });
     const { prompt } = await c.req.json();
     if (!prompt)
         return c.json({ error: 'prompt required' }, 400);
@@ -52,6 +52,19 @@ app.post('/api/generate', async (c) => {
         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}`);
-});
+export default app;
+const isMain = process.argv[1] === fileURLToPath(import.meta.url) || process.argv[1]?.endsWith('server.ts');
+if (isMain) {
+    if (!process.env["GEMINI_API_KEY"]) {
+        throw new Error("GEMINI_API_KEY environment variable is required");
+    }
+    const controller = new AbortController();
+    hw.watch(controller.signal);
+    process.on('SIGINT', () => {
+        controller.abort();
+        process.exit();
+    });
+    serve({ fetch: app.fetch, port }, (info) => {
+        console.log(`🚀 server at http://localhost:${info.port}`);
+    });
+}

package/dist/session-stream.d.ts

@@ -0,0 +1,40 @@
+import type { FileStat } from './label-generator.js';
+export type SessionEvent = {
+    type: 'session:info';
+    sessionId: string;
+    repo: string;
+    title: string;
+    state: string;
+} | {
+    type: 'activity:processed';
+    index: number;
+    activityId: string;
+    activityType: string;
+    summary: string;
+    files: FileStat[];
+    commitMessage?: string;
+    createTime?: string;
+} | {
+    type: 'session:complete';
+    sessionId: string;
+    totalActivities: number;
+} | {
+    type: 'session:error';
+    sessionId: string;
+    error: string;
+};
+export interface SessionStreamOptions {
+    model?: string;
+    tone?: string;
+    backend?: 'cloud' | 'local';
+    apiKey?: string;
+    live?: boolean;
+    signal?: AbortSignal;
+    afterIndex?: number;
+}
+/**
+ * Portable session streaming core.
+ * Yields typed events without any file I/O or printer coupling.
+ * Both CLI and Astro SSR consume this same generator.
+ */
+export declare function streamSession(sessionId: string, options?: SessionStreamOptions): AsyncGenerator<SessionEvent>;

package/dist/session-stream.js

@@ -0,0 +1,76 @@
+import { SessionSummarizer } from './summarizer.js';
+/**
+ * Portable session streaming core.
+ * Yields typed events without any file I/O or printer coupling.
+ * Both CLI and Astro SSR consume this same generator.
+ */
+export async function* streamSession(sessionId, options = {}) {
+    const { model, tone, backend = 'cloud', apiKey, live = true, signal, afterIndex = -1, } = options;
+    const summarizer = new SessionSummarizer({
+        backend,
+        apiKey: apiKey || process.env.GEMINI_API_KEY,
+        cloudModelName: model,
+        tone,
+    });
+    const { connect } = await import('@google/jules-sdk');
+    const jules = connect();
+    let rollingSummary = '';
+    const session = jules.session(sessionId);
+    // Emit session metadata
+    try {
+        const sessionInfo = await session.info();
+        const repo = sessionInfo.sourceContext?.source?.replace('sources/github/', '') || 'unknown/repo';
+        const title = sessionInfo.title || '';
+        const state = sessionInfo.state || '';
+        yield {
+            type: 'session:info',
+            sessionId,
+            repo,
+            title,
+            state,
+        };
+    }
+    catch (err) {
+        yield { type: 'session:error', sessionId, error: err.message || String(err) };
+        return;
+    }
+    // Stream activities
+    const activityStream = live ? session.stream() : session.history();
+    let count = 0;
+    try {
+        for await (const activity of activityStream) {
+            if (signal?.aborted)
+                break;
+            // Skip already-processed activities (for resume after pause)
+            if (count <= afterIndex) {
+                count++;
+                continue;
+            }
+            // Generate summary
+            rollingSummary = await summarizer.generateRollingSummary(rollingSummary, activity);
+            // Extract file stats
+            const files = summarizer.getLabelData(activity);
+            // Extract commit message if available
+            const changeSet = activity.artifacts?.find(a => a.type === 'changeSet');
+            const commitMessage = changeSet?.gitPatch?.suggestedCommitMessage;
+            yield {
+                type: 'activity:processed',
+                index: count,
+                activityId: activity.id,
+                activityType: activity.type,
+                summary: rollingSummary,
+                files,
+                commitMessage,
+                createTime: activity.createTime,
+            };
+            count++;
+        }
+    }
+    catch (err) {
+        yield { type: 'session:error', sessionId, error: err.message || String(err) };
+        return;
+    }
+    if (!signal?.aborted) {
+        yield { type: 'session:complete', sessionId, totalActivities: count };
+    }
+}

package/dist/summarizer.js

@@ -130,7 +130,7 @@ export class SessionSummarizer {
     // ... (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)
+        if (!changeSetArtifact || !changeSetArtifact.gitPatch)
             return [];
         const files = parseDiff(changeSetArtifact.gitPatch.unidiffPatch);
         return files
@@ -182,7 +182,7 @@ export class SessionSummarizer {
         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) {
+        if (changeSet && changeSet.gitPatch) {
             return {
                 ...base,
                 context: this.buildSmartContext(changeSet.gitPatch.unidiffPatch),

package/dist/tone-presets.d.ts

@@ -0,0 +1 @@
+export declare const TONE_PRESETS: readonly ["professional", "pirate", "shakespearean", "excited", "haiku", "noir"];

package/dist/tone-presets.js

@@ -0,0 +1,8 @@
+export const TONE_PRESETS = [
+    'professional',
+    'pirate',
+    'shakespearean',
+    'excited',
+    'haiku',
+    'noir',
+];

package/dist/tones.d.ts

@@ -0,0 +1,7 @@
+export interface Tone {
+    name: string;
+    instructions: string;
+}
+export declare function loadTones(): Promise<Tone[]>;
+export declare function saveTone(tone: Tone): Promise<Tone[]>;
+export declare function deleteTone(name: string): Promise<Tone[]>;