@qvac/harness 0.8.0 → 0.8.5

package/dist-lib/lib/tools/exec/adapters/python/run-session.js

@@ -105,72 +105,6 @@ async function runOnce(py, code, opts) {
     }
     return retry;
 }
-const FIT_DECKS = `
-def _qvac_fit_decks(names):
-    try:
-        from pptx import Presentation
-        from pptx.oxml.ns import qn
-    except Exception:
-        return
-    for name in names:
-        if not name.lower().endswith('.pptx'):
-            continue
-        try:
-            prs = Presentation(name)
-        except Exception:
-            continue
-        slide_height = prs.slide_height
-        changed = False
-        for slide in prs.slides:
-            for shape in slide.shapes:
-                if not shape.has_text_frame:
-                    continue
-                tf = shape.text_frame
-                text = tf.text or ''
-                if not text.strip():
-                    continue
-                tf.word_wrap = True
-                # Estimated wrapped lines against the box: a character at N pt is
-                # about 0.5 N wide and a line about 1.2 N tall. Rough on purpose —
-                # it only has to pick a scale, and the renderer does the real layout.
-                width_pt = (shape.width or 0) / 12700.0
-                height_pt = (shape.height or slide_height) / 12700.0
-                lines = 0
-                tallest = 0.0
-                for p in tf.paragraphs:
-                    # An unsized paragraph inherits from the layout, and the bundled
-                    # template's body is 28pt — assuming something smaller here is
-                    # what let a seven-bullet slide measure as fitting.
-                    size = p.font.size.pt if p.font.size is not None else 28.0
-                    tallest = max(tallest, size)
-                    per_line = max(1.0, width_pt / (size * 0.5))
-                    lines += max(1, int(len(p.text or '') / per_line) + 1)
-                needed = lines * max(tallest, 12.0) * 1.2
-                scale = 1.0 if needed <= height_pt or height_pt <= 0 else height_pt / needed
-                # 55% is the floor: below that the deck is unreadable from a room and
-                # the honest answer is fewer bullets, not smaller type.
-                scale = max(0.55, min(1.0, scale))
-                bodyPr = tf._txBody.bodyPr
-                for tag in ('a:normAutofit', 'a:spAutoFit', 'a:noAutofit'):
-                    found = bodyPr.find(qn(tag))
-                    if found is not None:
-                        bodyPr.remove(found)
-                bodyPr.append(
-                    bodyPr.makeelement(
-                        qn('a:normAutofit'),
-                        {
-                            'fontScale': str(int(scale * 100000)),
-                            'lnSpcReduction': '0' if scale >= 1.0 else '10000'
-                        }
-                    )
-                )
-                changed = True
-        if changed:
-            try:
-                prs.save(name)
-            except Exception:
-                pass
-`;
 class InstallTimeoutError extends Error {
 }
 function installSource(py, packages) {
@@ -213,21 +147,6 @@ function listFiles(py, dir) {
 function newDeliverables(before, after) {
     return [...after].filter((name) => !before.has(name) && DELIVERABLE.test(name));
 }
-function fitDecks(py, outputs) {
-    if (!outputs.some((name) => name.toLowerCase().endsWith('.pptx'))) {
-        return false;
-    }
-    try {
-        py.runPython(`${FIT_DECKS}\n_qvac_fit_decks(${JSON.stringify(outputs)})`);
-        return false;
-    }
-    catch (error) {
-        hlog('python: deck fit skipped', {
-            err: errorMessage(error)
-        });
-        return isPyodideFatal(error);
-    }
-}
 export async function performRun(py, spec, opts = {}) {
     const isCancelled = opts.isCancelled ?? (() => false);
     const ask = opts.askConnect ?? (async () => false);
@@ -297,10 +216,7 @@ export async function performRun(py, spec, opts = {}) {
             maxOutputChars: spec.maxOutputChars,
             access
         });
-        let evict = fatal;
-        if (result.exitCode === 0) {
-            evict = fitDecks(py, spec.outputs ?? []);
-        }
+        const evict = fatal;
         if (evict) {
             return { result: { ...result, missing: spec.outputs ?? [] }, evict };
         }

package/dist-lib/lib/tools/exec.js

@@ -1,8 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import { AbortedError } from '../helpers/race-abort.js';
-import { checkPdfBuildSource, checkBareLengthArgs, checkPptxBuildSource, checkPythonSource, checkUnstagedRead, createPythonAdapter, isPythonLanguage, parseInputs, parseOutputs, parsePackages, parseWorkdir, pinned, runsThroughPyodide, sandboxInstallError, unwrapPythonSource } from './exec/adapters/python/python-adapter.js';
-import { pythonCreateEffect } from './exec/adapters/python/create-effect.js';
+import { checkPythonSource, createPythonAdapter, isPythonLanguage, officeImportError, parseInputs, parseOutputs, parsePackages, parseWorkdir, pinned, runsThroughPyodide, sandboxInstallError, unwrapPythonSource } from './exec/adapters/python/python-adapter.js';
 import { namedHosts } from './exec/adapters/python/named-hosts.js';
 import { pythonReachesNetwork } from './exec/adapters/python/net-shim.js';
 import { createShellAdapter } from './exec/adapters/shell/shell-adapter.js';
@@ -422,7 +421,7 @@ export function createExecTool({ spawn, killProcess, loadPyodide, disablePyodide
                 return 'read';
             }
             if (runsThroughPyodide(args.language, disablePyodide)) {
-                return pythonCreateEffect(args);
+                return 'write';
             }
             return shellEffect(String(args.command ?? '').trim(), ctx?.toolOps);
         },
@@ -459,6 +458,13 @@ export function createExecTool({ spawn, killProcess, loadPyodide, disablePyodide
                 if (packages && 'error' in packages) {
                     return packages.error;
                 }
+                const office = officeImportError(unwrapPythonSource(command) ?? command, {
+                    packages,
+                    toolNames: ctx?.toolNames
+                });
+                if (office) {
+                    return office;
+                }
                 const refusal = ctx?.sandboxMode === true ? sandboxInstallError(command, packages) : null;
                 if (refusal) {
                     return refusal;
@@ -468,23 +474,6 @@ export function createExecTool({ spawn, killProcess, loadPyodide, disablePyodide
                     if (sourceError) {
                         return sourceError;
                     }
-                    const pptxError = checkPptxBuildSource(unwrapPythonSource(command) ?? command, outputs, packages);
-                    if (pptxError) {
-                        return pptxError;
-                    }
-                    const pdfError = checkPdfBuildSource(unwrapPythonSource(command) ?? command, outputs, packages);
-                    if (pdfError) {
-                        return pdfError;
-                    }
-                    const bareLength = checkBareLengthArgs(unwrapPythonSource(command) ?? command, packages);
-                    if (bareLength) {
-                        return bareLength;
-                    }
-                    const inputs = parseInputs(rawArgs.inputs);
-                    const unstagedRead = checkUnstagedRead(unwrapPythonSource(command) ?? command, Array.isArray(inputs) ? inputs : undefined);
-                    if (unstagedRead) {
-                        return unstagedRead;
-                    }
                 }
             }
             const parsed = parsePackages(rawArgs.packages);

package/dist-lib/lib/tools/office/ops.d.ts

@@ -0,0 +1,13 @@
+export type Slot = string | readonly string[];
+export interface OpSpec {
+    readonly slots: readonly Slot[];
+    readonly inches?: boolean;
+    readonly query?: boolean;
+    readonly aliases?: Readonly<Record<string, string>>;
+}
+export declare const PPTX_OPS: Readonly<Record<string, OpSpec>>;
+export declare const DOCX_OPS: Readonly<Record<string, OpSpec>>;
+export declare const XLSX_OPS: Readonly<Record<string, OpSpec>>;
+export declare function opKeys(spec: OpSpec): string[];
+export declare function withAliases(spec: OpSpec, op: Readonly<Record<string, unknown>>): Record<string, unknown>;
+export declare function opArguments(spec: OpSpec, op: Readonly<Record<string, unknown>>, toEmu: (inches: number) => number): unknown[];

package/dist-lib/lib/tools/office/ops.js

@@ -0,0 +1,100 @@
+const TABLE_INDEX = { index: 'table' };
+const BOX = ['x', 'y', 'width', 'height'];
+const CHART = ['type', 'categories', 'series', 'title', 'stacked', 'legend', 'name'];
+export const PPTX_OPS = {
+    read: { slots: [], query: true },
+    layouts: { slots: [], query: true },
+    setText: { slots: [['slide', 'shape'], 'text'] },
+    setCellText: { slots: [['slide', 'shape', 'row', 'column'], 'text'] },
+    setStyle: { slots: [['slide', 'shape'], 'style', ['paragraph']] },
+    addSlide: { slots: [['like', 'layout', 'at', 'title', 'body']] },
+    addPicture: { slots: ['slide', 'image', [...BOX, 'name', 'description']], inches: true },
+    addTextBox: { slots: ['slide', [...BOX, 'text', 'style', 'fill', 'name']], inches: true },
+    addTable: { slots: ['slide', [...BOX, 'rows', 'header', 'name']], inches: true },
+    addChart: { slots: ['slide', [...BOX, ...CHART]], inches: true },
+    setChartData: {
+        slots: [
+            ['slide', 'shape'],
+            ['categories', 'series']
+        ]
+    },
+    setChartTitle: { slots: [['slide', 'shape'], 'title'] },
+    setBackground: { slots: ['slide', 'color'] },
+    deleteSlide: { slots: ['slide'] },
+    moveSlide: { slots: ['from', ['to']] }
+};
+export const DOCX_OPS = {
+    read: { slots: [], query: true },
+    sections: { slots: [], query: true },
+    paragraphStyles: { slots: [], query: true },
+    setText: { slots: ['index', 'text'] },
+    insertParagraphs: { slots: ['at', 'paragraphs'] },
+    appendParagraphs: { slots: ['paragraphs'] },
+    replaceSection: { slots: ['index', ['title', 'body']] },
+    deleteSection: { slots: ['index'] },
+    deleteBlocks: { slots: ['index', ['count']] },
+    formatParagraph: { slots: ['index', 'format'] },
+    formatStyle: { slots: ['name', 'format'] },
+    addTable: { slots: ['at', ['rows', 'header', 'style']] },
+    setCell: { slots: [['table', 'row', 'column'], 'text'], aliases: TABLE_INDEX },
+    addRow: { slots: ['table', 'values', ['at']], aliases: TABLE_INDEX },
+    deleteRow: { slots: [['table', 'row']], aliases: TABLE_INDEX },
+    addImage: {
+        slots: ['at', 'image', ['width', 'height', 'align', 'name', 'description']],
+        inches: true
+    },
+    addChart: { slots: ['at', ['width', 'height', ...CHART]], inches: true },
+    setChartData: { slots: ['index', ['categories', 'series'], ['chart']] },
+    setChartTitle: { slots: ['index', 'title', ['chart']] }
+};
+export const XLSX_OPS = {
+    sheets: { slots: [], query: true },
+    read: { slots: ['sheet', ['range', 'limit']], query: true },
+    get: { slots: ['sheet', 'ref'], query: true },
+    setCells: { slots: ['sheet', 'cells'] },
+    appendRows: { slots: ['sheet', 'rows'] },
+    insertRows: { slots: ['sheet', ['at', 'rows', 'count']] },
+    deleteRows: { slots: ['sheet', ['at', 'count']] },
+    deleteColumns: { slots: ['sheet', ['column', 'count']] },
+    setColumnWidth: { slots: ['sheet', ['column', 'width']] },
+    addSheet: { slots: ['name', ['at']] },
+    renameSheet: { slots: ['sheet', 'name'] },
+    deleteSheet: { slots: ['sheet'] },
+    addImage: {
+        slots: ['sheet', 'image', ['cell', 'width', 'height', 'name', 'description']],
+        inches: true
+    },
+    removeMacros: { slots: [] }
+};
+const LENGTHS = new Set(BOX);
+export function opKeys(spec) {
+    const keys = spec.slots.flatMap((slot) => (typeof slot === 'string' ? [slot] : [...slot]));
+    return [...keys, ...Object.keys(spec.aliases ?? {})];
+}
+export function withAliases(spec, op) {
+    const named = { ...op };
+    for (const [alias, key] of Object.entries(spec.aliases ?? {})) {
+        if (alias in named && named[key] === undefined) {
+            named[key] = named[alias];
+        }
+        delete named[alias];
+    }
+    return named;
+}
+export function opArguments(spec, op, toEmu) {
+    const value = (key) => {
+        const raw = op[key];
+        return spec.inches && LENGTHS.has(key) && typeof raw === 'number' ? toEmu(raw) : raw;
+    };
+    const args = spec.slots.map((slot) => {
+        if (typeof slot === 'string') {
+            return value(slot);
+        }
+        const present = slot.filter((key) => op[key] !== undefined);
+        return present.length ? Object.fromEntries(present.map((key) => [key, value(key)])) : undefined;
+    });
+    while (args.length && args.at(-1) === undefined) {
+        args.pop();
+    }
+    return args;
+}

package/dist-lib/lib/tools/office.d.ts

@@ -0,0 +1,12 @@
+import type { ToolDefinition } from '../capabilities/completion.ts';
+import { pptx, xlsx } from '../office/engine/index.ts';
+type Deck = ReturnType<typeof pptx.open>;
+type Workbook = ReturnType<typeof xlsx.open>;
+type FormatName = 'pptx' | 'docx' | 'xlsx';
+type Args = Record<string, unknown>;
+export declare function shapeFor(deck: Deck, op: Args): Args;
+export declare function sheetFor(book: Workbook, op: Args, created: boolean): Args;
+export declare function normalizeArgs(args: Args): Args;
+export declare function revisedName(format: FormatName, fileName: string): string;
+export declare function createOfficeTools(): ToolDefinition[];
+export {};