@qvac/harness 1.0.0-rc.0 → 1.0.0-rc.2

package/dist-lib/lib/tools/file-glob.d.ts

@@ -1,4 +1,4 @@
-import type { ToolDefinition } from '../capabilities/completion.ts';
+import type { ToolDefinition } from '../contract/index.ts';
 import { type DriveRoot, type FsToolError, type FsToolOptions, type ResolveKeyOptions } from './fs/scope.ts';
 export declare const DEFAULT_GLOB_MATCHES = 100;
 export declare const MAX_GLOB_MATCHES = 1000;

package/dist-lib/lib/tools/file-glob.js

@@ -57,6 +57,7 @@ export function createFileGlobTool({ realpath = defaultRealpath, deniedRoots } =
             required: ['pattern']
         },
         effect: () => 'read',
+        concurrent: true,
         autoApprove: true,
         rootsRequired: true,
         validate(rawArgs) {

package/dist-lib/lib/tools/fs/scope.d.ts

@@ -27,6 +27,7 @@ export declare function deniedRootsFor(sdkHome: string | undefined): readonly st
 export declare const PROTECTED_PATH_ERROR = "path is inside a protected app directory";
 export declare function canonicalDenyRoots(deniedRoots: readonly string[] | undefined, realpath: Realpath): Promise<readonly string[]>;
 export declare function isDeniedPath(hostPath: string, canonicalDenyRoots: readonly string[]): boolean;
+export declare function overlaps(a: string, b: string): boolean;
 export declare function hostPath(root: LocalRoot, key: string): string;
 export declare function displayPath(root: DriveRoot, key: string): string;
 export declare function normalizeDriveKey(prefix: string, input: string): string | null;

package/dist-lib/lib/tools/fs/scope.js

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import process from 'process';
+import { SPILL_DIR } from '../../spill.js';
 export const defaultRealpath = (p) => fs.promises.realpath(p);
 export const NO_DIRS_GRANTED = 'no directories are granted';
 const HYPER_PREFIX = 'hyper://';
@@ -14,7 +15,7 @@ export const NO_STORAGE_ROOT = 'cannot fence the app storage root: the SDK home
 export function deniedRootsFor(sdkHome) {
     if (!sdkHome)
         throw new Error(NO_STORAGE_ROOT);
-    return [path.dirname(sdkHome)];
+    return [path.dirname(sdkHome), SPILL_DIR];
 }
 export const PROTECTED_PATH_ERROR = 'path is inside a protected app directory';
 function protectedPath() {
@@ -24,11 +25,12 @@ export async function canonicalDenyRoots(deniedRoots, realpath) {
     if (!deniedRoots?.length)
         return [];
     return Promise.all(deniedRoots.map(async (raw) => {
+        const resolved = path.resolve(raw);
         try {
-            return await realpath(raw);
+            return await realpath(resolved);
         }
         catch {
-            return path.resolve(raw);
+            return realpath(path.dirname(resolved)).then((parent) => path.join(parent, path.basename(resolved)), () => resolved);
         }
     }));
 }
@@ -39,6 +41,9 @@ const FOLD_CASE = process.platform === 'darwin' || process.platform === 'win32';
 function within(candidate, root) {
     return contained(candidate, root, { ignoreCase: FOLD_CASE });
 }
+export function overlaps(a, b) {
+    return within(a, b) || within(b, a);
+}
 function contained(candidate, root, { ignoreCase }) {
     const a = ignoreCase ? candidate.toLowerCase() : candidate;
     const b = ignoreCase ? root.toLowerCase() : root;

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

@@ -1,4 +1,4 @@
-import type { ToolDefinition } from '../capabilities/completion.ts';
+import type { ToolDefinition } from '../contract/index.ts';
 import { type FsToolOptions } from './fs/scope.ts';
 export declare const DEFAULT_GREP_MATCHES = 200;
 export declare const MAX_GREP_MATCHES = 1000;

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

@@ -99,6 +99,7 @@ export function createGrepTool({ realpath = defaultRealpath, deniedRoots } = {})
             required: ['queries']
         },
         effect: () => 'read',
+        concurrent: true,
         autoApprove: true,
         rootsRequired: true,
         validate(rawArgs) {

package/dist-lib/lib/tools/http-request.d.ts

@@ -1,4 +1,4 @@
-import type { ToolDefinition } from '../capabilities/completion.ts';
+import type { ToolDefinition } from '../contract/index.ts';
 import { type FetchInit } from './http-request/request.ts';
 import { type CredentialAllowListFn, type CredentialStoreFn } from './skills/auth-resolver.ts';
 import { type HostResolver } from './url-guard.ts';

package/dist-lib/lib/tools/http-request.js

@@ -53,6 +53,7 @@ export function createHttpRequestTool({ policyVersion, fetch: fetchImpl, credent
             }
             return args.body === undefined && args.encode === undefined ? 'read' : 'write';
         },
+        egress: (args) => (typeof args.url === 'string' ? args.url : null),
         resource(args) {
             try {
                 return { kind: 'host', label: new URL(String(args.url)).hostname };

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

@@ -0,0 +1,21 @@
+import type { ToolDefinition } from '../contract/index.ts';
+import { deniedRootsFor } from './fs/scope.ts';
+import { compileOperationTools } from './operations/compile.ts';
+import { stageInputs } from './attachments/staging.ts';
+import type { CredentialStoreFn } from './skills/auth-resolver.ts';
+import { ensureBundledSkillsDir } from './skills/bundled-dir.ts';
+import type { SkillCatalogEntry } from './skills/catalog.ts';
+export type { ExecInput } from './attachments/staging.ts';
+export interface ProductToolsOptions {
+    readonly sdkHome: string;
+    readonly skillsDir?: string | undefined;
+    readonly skillCatalog?: readonly SkillCatalogEntry[] | undefined;
+    readonly credentialStore?: CredentialStoreFn | undefined;
+}
+export declare class Tools {
+    static deniedRoots: typeof deniedRootsFor;
+    static bundledSkillsDir: typeof ensureBundledSkillsDir;
+    static stageInputs: typeof stageInputs;
+    static operations: typeof compileOperationTools;
+    static product({ sdkHome, skillsDir, skillCatalog, credentialStore }: ProductToolsOptions): ToolDefinition[];
+}

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

@@ -0,0 +1,46 @@
+import { createCreateDocumentsTool } from './create-documents.js';
+import { createEditDocumentsTool } from './edit-documents.js';
+import { createFileGlobTool } from './file-glob.js';
+import { deniedRootsFor } from './fs/scope.js';
+import { createGrepTool } from './grep.js';
+import { createHttpRequestTool } from './http-request.js';
+import { createOfficeTools } from './office.js';
+import { compileOperationTools } from './operations/compile.js';
+import { createPdfTool } from './pdf.js';
+import { createReadFilesTool } from './read-files.js';
+import { createSkillTool } from './skill.js';
+import { stageInputs } from './attachments/staging.js';
+import { ensureBundledSkillsDir } from './skills/bundled-dir.js';
+import { credentialAllowListFor } from './skills/credential-grants.js';
+import { createWebFetchTool } from './web-fetch.js';
+export class Tools {
+    static deniedRoots = deniedRootsFor;
+    static bundledSkillsDir = ensureBundledSkillsDir;
+    static stageInputs = stageInputs;
+    static operations = compileOperationTools;
+    static product({ sdkHome, skillsDir, skillCatalog, credentialStore }) {
+        const deniedRoots = deniedRootsFor(sdkHome);
+        const credentialed = skillCatalog
+            ? { credentialStore, credentialAllowList: credentialAllowListFor(skillCatalog) }
+            : undefined;
+        const httpRequestTool = createHttpRequestTool(credentialed);
+        const tools = [
+            httpRequestTool,
+            createWebFetchTool(),
+            createReadFilesTool({ deniedRoots }),
+            createFileGlobTool({ deniedRoots }),
+            createGrepTool({ deniedRoots }),
+            createCreateDocumentsTool({ deniedRoots }),
+            createEditDocumentsTool({ deniedRoots }),
+            createPdfTool(),
+            ...createOfficeTools()
+        ];
+        if (skillCatalog) {
+            tools.push(...compileOperationTools(skillCatalog, { httpRequestTool }));
+        }
+        if (skillsDir) {
+            tools.push(createSkillTool({ skillsDir }));
+        }
+        return tools;
+    }
+}

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 '../contract/index.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 {};