onbuzz 4.9.5 → 4.9.8

package/src/tools/office/pres/edit/read.js

@@ -0,0 +1,105 @@
+/**
+ * pres/edit/read — outline + token discovery for an existing .pptx.
+ *
+ * A .pptx is a ZIP archive containing slide XML files under
+ *   ppt/slides/slide1.xml, slide2.xml, ...
+ * Each slide XML has `<a:t>...</a:t>` text runs. We unzip in memory,
+ * walk the slides, extract their text content, and detect any
+ * `{{tokens}}` the agent can later fill via pres/edit/fill.
+ *
+ * Used by the `pres.read` action.
+ */
+import fs from 'fs/promises';
+import { createRequire } from 'module';
+
+const localRequire = createRequire(import.meta.url);
+let JSZip = null;
+function loadZip() {
+  if (JSZip) return JSZip;
+  JSZip = localRequire('jszip');
+  return JSZip;
+}
+
+const TEXT_RUN_RE = /<a:t[^>]*>([\s\S]*?)<\/a:t>/g;
+const TOKEN_RE = /\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g;
+
+function decodeXml(s) {
+  return String(s)
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'");
+}
+
+function extractText(xml) {
+  const lines = [];
+  let m;
+  TEXT_RUN_RE.lastIndex = 0;
+  while ((m = TEXT_RUN_RE.exec(xml)) !== null) {
+    const txt = decodeXml(m[1]).trim();
+    if (txt) lines.push(txt);
+  }
+  return lines;
+}
+
+function extractTokens(xml) {
+  const found = new Set();
+  let m;
+  TOKEN_RE.lastIndex = 0;
+  while ((m = TOKEN_RE.exec(xml)) !== null) {
+    found.add(m[1]);
+  }
+  return [...found];
+}
+
+/**
+ * Read the structural outline of a .pptx file.
+ *
+ *   {
+ *     slideCount,
+ *     slides: [
+ *       { index, title, body: [...], tokens: ['name', 'date', ...] }
+ *     ],
+ *     tokens: ['name', 'date', ...]    // union across all slides
+ *   }
+ *
+ * `title` is the first non-empty text run on the slide (a reasonable
+ * heuristic — PPTX has no semantic "title" annotation by default).
+ */
+export async function readPres(filePath) {
+  const Zip = loadZip();
+  const buf = await fs.readFile(filePath);
+  const zip = await Zip.loadAsync(buf);
+
+  const slideFiles = Object.keys(zip.files)
+    .filter(p => /^ppt\/slides\/slide\d+\.xml$/.test(p))
+    .sort((a, b) => {
+      const ai = Number(a.match(/(\d+)\.xml$/)[1]);
+      const bi = Number(b.match(/(\d+)\.xml$/)[1]);
+      return ai - bi;
+    });
+
+  const slides = [];
+  const tokenSet = new Set();
+
+  for (let i = 0; i < slideFiles.length; i++) {
+    const xml = await zip.file(slideFiles[i]).async('string');
+    const runs = extractText(xml);
+    const tokens = extractTokens(xml);
+    tokens.forEach(t => tokenSet.add(t));
+    slides.push({
+      index: i,
+      file: slideFiles[i],
+      title: runs[0] || '',
+      body: runs.slice(1),
+      tokens,
+    });
+  }
+
+  return {
+    slideCount: slides.length,
+    slides,
+    tokens: [...tokenSet],
+  };
+}

package/src/tools/office/pres/index.js

@@ -0,0 +1,100 @@
+/**
+ * pres — themed presentation builder.
+ *
+ * Public entry. Takes the spec the agent provides + an output path,
+ * builds the pptx via pptxgenjs, writes to disk, returns metadata.
+ *
+ * Spec shape:
+ *   {
+ *     title, subject, author, company,
+ *     theme: 'editorial-warm' | 'tech-bold' | 'data-heavy',
+ *     palette, spacing, shape, background,   // optional overrides
+ *     slides: [
+ *       { archetype: 'hero', title, subtitle, eyebrow, ... },
+ *       { archetype: 'agenda', items: [...] },
+ *       ...
+ *     ]
+ *   }
+ *
+ * The new system is opt-in by passing a STRING `theme`. The legacy
+ * shape (theme as an object) is still routed to the old createPres
+ * by the caller in officePres.js.
+ */
+import fs from 'fs/promises';
+import { createRequire } from 'module';
+
+import { resolveTheme, listThemes } from './themes/index.js';
+import { renderArchetype, listArchetypes } from './archetypes/index.js';
+import { listBackgrounds } from './backgrounds/index.js';
+import { defineMasters, buildDeckContext, usesChrome } from './master.js';
+
+const localRequire = createRequire(import.meta.url);
+let pptxgen = null;
+function loadPptx() {
+  if (pptxgen) return pptxgen;
+  const mod = localRequire('pptxgenjs');
+  pptxgen = mod.default || mod;
+  return pptxgen;
+}
+
+/**
+ * Detect the new-format spec — distinguishes from the legacy shape so
+ * officePres.createPres() can route appropriately.
+ */
+export function isThemedSpec(spec) {
+  return !!(spec && typeof spec.theme === 'string');
+}
+
+/** Discovery helpers — used by the verifier + tool description builder. */
+export function listSystem() {
+  return {
+    themes: listThemes(),
+    archetypes: listArchetypes(),
+    backgrounds: listBackgrounds(),
+  };
+}
+
+/**
+ * Build a themed presentation. Returns {path, size, slideCount, theme}.
+ */
+export async function buildThemedPres(spec, outputPath) {
+  const Pptx = loadPptx();
+  const pptx = new Pptx();
+
+  pptx.title = spec.title || '';
+  pptx.subject = spec.subject || '';
+  pptx.author = spec.author || 'Loxia Agent';
+  pptx.company = spec.company || '';
+  pptx.layout = 'LAYOUT_WIDE';
+
+  const resolved = resolveTheme(spec);
+  const { slides, context } = buildDeckContext(spec);
+
+  // Two slide masters per deck so we can apply consistent bg/chrome
+  // and let pptxgenjs dedupe the static parts at file-size level.
+  const masters = defineMasters(pptx, resolved);
+
+  for (let i = 0; i < slides.length; i++) {
+    const slideSpec = slides[i];
+    const ctx = context[i];
+    const masterName = usesChrome(slideSpec.archetype || 'freeform')
+      ? masters.CHROME
+      : masters.BARE;
+    const slide = pptx.addSlide({ masterName });
+    renderArchetype(slide, resolved, slideSpec, pptx, ctx);
+  }
+
+  const buf = await pptx.write({ outputType: 'nodebuffer' });
+  await fs.writeFile(outputPath, buf);
+  const stat = await fs.stat(outputPath);
+  return {
+    path: outputPath,
+    size: stat.size,
+    slideCount: slides.length,
+    theme: resolved.theme.id,
+    palette: resolved.palette.name,
+    spacing: resolved.spacing.preset,
+    shape: resolved.shape.preset,
+    background: resolved.bg,
+  };
+}

package/src/tools/office/pres/master.js

@@ -0,0 +1,107 @@
+/**
+ * pres/master — slide master + deck-level context.
+ *
+ * pptxgenjs's `defineSlideMaster` lets us put recurring chrome (bg
+ * colour, static brand strip, page-number placeholder, decorative
+ * accent shapes) in one place so the file size shrinks and every
+ * slide stays in lockstep visually. The dynamic per-slide chrome
+ * (section name + slide-number text + section progress dots) still
+ * lives on the slide itself — pptxgenjs's master placeholders can't
+ * read per-slide data.
+ *
+ * The deck context is computed once per build: it tracks which
+ * section each slide belongs to (by walking the slide list and
+ * resetting on every sectionHeader archetype) so the chrome can show
+ * "01 / 04" indicators without the agent labelling each slide.
+ */
+import { SLIDE_DIMENSIONS } from './grid.js';
+
+/** Archetypes that intentionally suppress header/footer chrome. */
+const BARE_ARCHETYPES = new Set([
+  'hero', 'sectionHeader', 'closing', 'imageFullBleed',
+  'headlineMessage', 'productHero',
+]);
+
+/** True iff this archetype should render with the chrome master. */
+export function usesChrome(archetypeId) {
+  return !BARE_ARCHETYPES.has(archetypeId);
+}
+
+/**
+ * Define one slide master per theme. We register two variants:
+ *   LOXIA_BARE   — used by hero / section / closing / imageFullBleed
+ *                  (background only; archetype owns the entire canvas)
+ *   LOXIA_CHROME — used by everything else; same background + an
+ *                  ultra-thin accent stripe at top (the dynamic
+ *                  section name + page number sit on the slide via
+ *                  headerChrome/footerChrome).
+ *
+ * Returns the names so the caller can pick the right one per slide.
+ */
+export function defineMasters(pptx, resolved) {
+  const palette = resolved.palette;
+
+  pptx.defineSlideMaster({
+    title: 'LOXIA_BARE',
+    background: { color: palette.bg },
+    objects: [],
+  });
+
+  pptx.defineSlideMaster({
+    title: 'LOXIA_CHROME',
+    background: { color: palette.bg },
+    objects: [
+      // Top accent hairline — the single piece of static chrome the
+      // master can place. Section name + page number are dynamic and
+      // are added per slide.
+      { rect: { x: 0, y: 0, w: SLIDE_DIMENSIONS.width, h: 0.04, fill: { color: palette.primary } } },
+    ],
+  });
+
+  return { BARE: 'LOXIA_BARE', CHROME: 'LOXIA_CHROME' };
+}
+
+/**
+ * Pre-compute a context for every slide so archetypes can render
+ * section progress / page numbers without the agent labelling each
+ * slide manually.
+ *
+ *   { slides: [...originalSlides], context: [{slideIndex, totalSlides,
+ *     sectionName, sectionIdx, sectionTotal, brand, isSectionStart}] }
+ */
+export function buildDeckContext(spec) {
+  const slides = Array.isArray(spec.slides) ? spec.slides : [];
+  const totalSlides = slides.length;
+
+  // First pass: collect sections (sectionHeader slides) so we know
+  // how many total + what their names are.
+  const sections = [];
+  slides.forEach((s, i) => {
+    if (s.archetype === 'sectionHeader') {
+      sections.push({ idx: sections.length, slideIndex: i, name: s.title || `Section ${sections.length + 1}` });
+    }
+  });
+  const sectionTotal = sections.length;
+
+  // Second pass: assign each slide to a section based on which
+  // sectionHeader came before it.
+  const context = [];
+  let currentSectionIdx = -1;
+  for (let i = 0; i < slides.length; i++) {
+    if (slides[i].archetype === 'sectionHeader') {
+      currentSectionIdx++;
+    }
+    const sectionName = currentSectionIdx >= 0 ? sections[currentSectionIdx].name : null;
+    context.push({
+      slideIndex: i,
+      totalSlides,
+      sectionName,
+      sectionIdx: Math.max(0, currentSectionIdx),
+      sectionTotal,
+      brand: spec.company || spec.title || '',
+      isSectionStart: slides[i].archetype === 'sectionHeader',
+    });
+  }
+
+  return { slides, context };
+}

package/src/tools/office/pres/palettes.js

@@ -17,92 +17,164 @@
  * accepts both but the no-# form is canonical in PPTX XML.
  */
 
+/**
+ * Palette = 8 semantic roles:
+ *   bg        slide background
+ *   surface   raised panels / cards / soft callouts
+ *   text      primary body colour
+ *   subtle    captions, dividers, secondary labels
+ *   primary   the deck's leading accent — titles, key data, primary CTAs
+ *   accent    secondary accent — chart series #2, eyebrows, links
+ *   ink       deepest emphasis — headlines that need to shout, pull-quote glyphs
+ *   highlight bright marker colour — pill backgrounds, badges, tag chips
+ *             (deliberately distinct from `accent` so component chrome has its own slot)
+ */
 export const PALETTES = {
   // ─── editorial-warm family ─────────────────────────────────────────
   'cream-charcoal': {
     family: 'editorial',
-    bg:      'FAF6EE',
-    surface: 'FFFFFF',
-    text:    '1A1A1A',
-    subtle:  '7A7368',
-    primary: 'C04A2D',
-    accent:  'E0B872',
+    bg:        'FAF6EE',
+    surface:   'FFFFFF',
+    text:      '1A1A1A',
+    subtle:    '7A7368',
+    primary:   'C04A2D',
+    accent:    'E0B872',
+    ink:       '0E0908',
+    highlight: 'E5594F',
   },
   'ink-paper': {
     family: 'editorial',
-    bg:      'FCFCF7',
-    surface: 'FFFFFF',
-    text:    '0E0E0E',
-    subtle:  '5A5A5A',
-    primary: '1B1B1B',
-    accent:  'B89060',
+    bg:        'FCFCF7',
+    surface:   'FFFFFF',
+    text:      '0E0E0E',
+    subtle:    '5A5A5A',
+    primary:   '1B1B1B',
+    accent:    'B89060',
+    ink:       '000000',
+    highlight: 'FFE45E',
   },
   'mint-charcoal': {
     family: 'editorial',
-    bg:      'F2F7F4',
-    surface: 'FFFFFF',
-    text:    '1A2620',
-    subtle:  '6A7B73',
-    primary: '2E5E50',
-    accent:  'A8C9B4',
+    bg:        'F2F7F4',
+    surface:   'FFFFFF',
+    text:      '1A2620',
+    subtle:    '6A7B73',
+    primary:   '2E5E50',
+    accent:    'A8C9B4',
+    ink:       '0A1410',
+    highlight: 'FFB300',
   },
 
   // ─── tech-bold family ──────────────────────────────────────────────
   'electric-night': {
     family: 'tech',
-    bg:      '0A0E1B',
-    surface: '151B2E',
-    text:    'F5F7FA',
-    subtle:  '8A93A8',
-    primary: '5B8DEF',
-    accent:  'F25F4C',
+    bg:        '0A0E1B',
+    surface:   '151B2E',
+    text:      'F5F7FA',
+    subtle:    '8A93A8',
+    primary:   '5B8DEF',
+    accent:    'F25F4C',
+    ink:       'FFFFFF',
+    highlight: 'FFD166',
   },
   'cyber-dawn': {
     family: 'tech',
-    bg:      'FFFFFF',
-    surface: 'F4F6FA',
-    text:    '0A0E1B',
-    subtle:  '6E7488',
-    primary: '4F6DF5',
-    accent:  'F25F4C',
+    bg:        'FFFFFF',
+    surface:   'F4F6FA',
+    text:      '0A0E1B',
+    subtle:    '6E7488',
+    primary:   '4F6DF5',
+    accent:    'F25F4C',
+    ink:       '000000',
+    highlight: '14B8A6',
   },
   'neon-violet': {
     family: 'tech',
-    bg:      '0F0A1B',
-    surface: '1A1330',
-    text:    'F5F0FF',
-    subtle:  '8E84B5',
-    primary: 'A87FFF',
-    accent:  'FFD166',
+    bg:        '0F0A1B',
+    surface:   '1A1330',
+    text:      'F5F0FF',
+    subtle:    '8E84B5',
+    primary:   'A87FFF',
+    accent:    'FFD166',
+    ink:       'FFFFFF',
+    highlight: 'FF6FA3',
+  },
+  // Linear product palette — explicitly WARM grays (not blue-grays).
+  // Background #08090A, surface #1C1D1F, text #F7F8F8 — matches
+  // Linear's post-refresh dark mode tone. Purple orb #5E6AD2 lives in
+  // the primary slot for hero accent moments.
+  'linear-product': {
+    family: 'tech',
+    bg:        '08090A',
+    surface:   '1C1D1F',
+    text:      'F7F8F8',
+    subtle:    '9A9CA0',
+    primary:   '5E6AD2',
+    accent:    '7B68EE',
+    ink:       'FFFFFF',
+    highlight: '4EA8DE',
   },
 
   // ─── data-heavy family ─────────────────────────────────────────────
   'bloomberg': {
     family: 'data',
-    bg:      'FFFFFF',
-    surface: 'F4F4F4',
-    text:    '1A1A1A',
-    subtle:  '6B6B6B',
-    primary: 'FF6600',
-    accent:  '0066CC',
+    bg:        'FFFFFF',
+    surface:   'F4F4F4',
+    text:      '1A1A1A',
+    subtle:    '6B6B6B',
+    primary:   'FF6600',
+    accent:    '0066CC',
+    ink:       '000000',
+    highlight: 'FFEB00',
   },
   'mono-data': {
     family: 'data',
-    bg:      'FFFFFF',
-    surface: 'F2F2F2',
-    text:    '1A1A1A',
-    subtle:  '8C8C8C',
-    primary: '111111',
-    accent:  'D62728',
+    bg:        'FFFFFF',
+    surface:   'F2F2F2',
+    text:      '1A1A1A',
+    subtle:    '8C8C8C',
+    primary:   '111111',
+    accent:    'D62728',
+    ink:       '000000',
+    highlight: 'FFD60A',
   },
   'finch': {
     family: 'data',
-    bg:      'FAFAF7',
-    surface: 'FFFFFF',
-    text:    '1D1D1F',
-    subtle:  '86868B',
-    primary: '055CA8',
-    accent:  '00A878',
+    bg:        'FAFAF7',
+    surface:   'FFFFFF',
+    text:      '1D1D1F',
+    subtle:    '86868B',
+    primary:   '055CA8',
+    accent:    '00A878',
+    ink:       '0A0E1B',
+    highlight: 'FFD166',
+  },
+
+  // ─── mono-keynote family (Vercel / Geist energy) ───────────────────
+  // Pure-mode palettes for the Vercel-class theme. Single accent (Geist
+  // blue), surfaces in pure greyscale, ink + highlight reserved for
+  // the rare moments of colour.
+  'mono-light': {
+    family: 'mono',
+    bg:        'FFFFFF',
+    surface:   'FAFAFA',
+    text:      '0A0A0A',
+    subtle:    '737373',
+    primary:   '0070F3',   // Geist blue
+    accent:    '0A0A0A',
+    ink:       '000000',
+    highlight: 'FFE45E',   // sticky-note yellow for callout highlights
+  },
+  'mono-dark': {
+    family: 'mono',
+    bg:        '000000',
+    surface:   '0A0A0A',
+    text:      'FAFAFA',
+    subtle:    '737373',
+    primary:   '0070F3',   // Geist blue
+    accent:    'FAFAFA',
+    ink:       'FFFFFF',
+    highlight: 'FFE45E',
   },
 };
 
@@ -119,9 +191,15 @@ export const CHART_SERIES = {
   'electric-night': ['5B8DEF', 'F25F4C', '6DD3CE', 'FFD166', 'BC83FF'],
   'cyber-dawn':     ['4F6DF5', 'F25F4C', '14B8A6', 'F59E0B', '7C3AED'],
   'neon-violet':    ['A87FFF', 'FFD166', 'FF6FA3', '4ECDC4', 'A5D8FF'],
+  'linear-product': ['5E6AD2', '7B68EE', '4EA8DE', 'F7B955', 'EF4444'],
   'bloomberg':      ['FF6600', '0066CC', 'CC3300', '009933', '6633CC'],
   'mono-data':      ['111111', '8C8C8C', 'D62728', '2CA02C', 'C5B0D5'],
   'finch':          ['055CA8', '00A878', 'F4A261', 'E76F51', '264653'],
+  // Vercel/Geist palette family — single accent + greyscale ladder for
+  // additional series. Avoids the rainbow chart look that fights the
+  // monochrome canvas.
+  'mono-light':     ['0070F3', '000000', '737373', '0A0A0A', 'B3B3B3'],
+  'mono-dark':      ['0070F3', 'FFFFFF', '737373', 'CCCCCC', '4D4D4D'],
 };
 
 /**
@@ -132,6 +210,7 @@ export const DEFAULT_PALETTE_BY_FAMILY = {
   editorial: 'cream-charcoal',
   tech:      'electric-night',
   data:      'bloomberg',
+  mono:      'mono-light',
 };
 
 /**

package/src/tools/office/pres/themes/data-heavy.js

@@ -25,17 +25,21 @@ export default {
     display: 'Calibri',
     body:    'Calibri',
     mono:    'Consolas',
+    // Data-heavy stays tighter than the other two themes — readers are
+    // closer to the page (printable analyst report posture) — but the
+    // sizes still need to be conference-readable. Old scale was too
+    // close to "Word document"; this is "FT print spread".
     sizes: {
-      display:  48,
-      title:    24,
-      subtitle: 14,
-      body:     12,
-      caption:  9,
-      stat:     72,
-      eyebrow:  9,
+      display:  80,
+      title:    38,
+      subtitle: 22,
+      body:     17,
+      caption:  12,
+      stat:     176,
+      eyebrow:  12,
     },
     weights: { display: 'bold', title: 'bold', subtitle: 'normal' },
-    letterSpacing: { display: -1, title: 0, eyebrow: 2 },
+    letterSpacing: { display: -2, title: -0.5, eyebrow: 2 },
   }),
   archetypes: {
     hero: {

package/src/tools/office/pres/themes/editorial-warm.js

@@ -25,17 +25,21 @@ export default {
     display: 'Georgia',
     body:    'Calibri',
     mono:    'Consolas',
+    // Sizes calibrated for "designed editorial" reading distance — the
+    // hero title fills the slide; body copy is comfortably readable from
+    // the back of a room. The previous scale was magazine-WEB; this is
+    // magazine-CONFERENCE.
     sizes: {
-      display:  60,
-      title:    32,
-      subtitle: 18,
-      body:     14,
-      caption:  10,
-      stat:     108,
-      eyebrow:  10,
+      display:  96,
+      title:    48,
+      subtitle: 26,
+      body:     20,
+      caption:  13,
+      stat:     220,
+      eyebrow:  14,
     },
     weights: { subtitle: 'normal' },
-    letterSpacing: { display: -2, title: -1, eyebrow: 3 },
+    letterSpacing: { display: -3, title: -1.5, eyebrow: 3 },
   }),
   /** Archetype-specific tweaks. Each archetype reads `theme.archetypes[id]`
    *  with falls back to {}. Used to shift defaults without forking the

package/src/tools/office/pres/themes/index.js

@@ -14,6 +14,7 @@
 import editorialWarm from './editorial-warm.js';
 import techBold from './tech-bold.js';
 import dataHeavy from './data-heavy.js';
+import monoKeynote from './mono-keynote.js';
 
 import { resolvePalette } from '../palettes.js';
 import { resolveSpacing } from '../grid.js';
@@ -23,6 +24,7 @@ const THEMES = {
   'editorial-warm': editorialWarm,
   'tech-bold':      techBold,
   'data-heavy':     dataHeavy,
+  'mono-keynote':   monoKeynote,
 };
 
 /**