@qvac/harness 0.4.0 → 0.6.0

package/dist-lib/lib/tools/exec/obsidian/vault-paths.js

@@ -13,8 +13,9 @@ export function resolveNotePath(vaultPath, args) {
         const name = fileArg.slice('file='.length);
         const withExt = name.endsWith('.md') ? name : `${name}.md`;
         const direct = ensureWithinRoot(vaultPath, withExt);
-        if (fs.existsSync(direct))
+        if (fs.existsSync(direct)) {
             return direct;
+        }
         return findFileRecursive(vaultPath, withExt);
     }
     return null;
@@ -32,8 +33,9 @@ function readDirEntries(dir) {
         if (name.startsWith('.'))
             continue;
         const full = path.join(dir, name);
-        if (isSymlink(full))
+        if (isSymlink(full)) {
             continue;
+        }
         let stat;
         try {
             stat = fs.statSync(full);
@@ -52,8 +54,9 @@ function findFileRecursive(dir, target) {
     for (const entry of readDirEntries(dir)) {
         if (entry.isDir) {
             const found = findFileRecursive(entry.full, target);
-            if (found)
+            if (found) {
                 return found;
+            }
         }
         else if (namesMatch(entry.name, target)) {
             return entry.full;
@@ -72,8 +75,9 @@ export function readFileSnapshot(filePath) {
     catch {
         return null;
     }
-    if (!stat.isFile())
+    if (!stat.isFile()) {
         return null;
+    }
     return { text: fs.readFileSync(filePath, 'utf8'), mtimeMs: stat.mtimeMs };
 }
 export function writeIfUnchanged(filePath, content, expectedMtimeMs) {
@@ -116,10 +120,12 @@ export function listMarkdownFiles(dir, prefix = '') {
     const results = [];
     for (const entry of readDirEntries(dir)) {
         const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-        if (entry.isDir)
+        if (entry.isDir) {
             results.push(...listMarkdownFiles(entry.full, rel));
-        else if (entry.name.endsWith('.md'))
+        }
+        else if (entry.name.endsWith('.md')) {
             results.push(rel);
+        }
     }
     return results;
 }
@@ -136,24 +142,28 @@ export function listFolders(dir, prefix = '') {
 }
 export function parseFrontmatter(content) {
     const match = content.match(FRONTMATTER_RE);
-    if (!match?.[1])
+    if (!match?.[1]) {
         return {};
+    }
     const props = {};
     for (const line of match[1].split('\n')) {
         const colonIdx = line.indexOf(':');
-        if (colonIdx === -1)
+        if (colonIdx === -1) {
             continue;
+        }
         const key = line.slice(0, colonIdx).trim();
         const value = line.slice(colonIdx + 1).trim();
-        if (key)
+        if (key) {
             props[key] = value;
+        }
     }
     return props;
 }
 export function getContentArg(args) {
     const arg = args.find((a) => a.startsWith('content='));
-    if (!arg)
+    if (!arg) {
         return '';
+    }
     return arg.slice('content='.length).replace(/\\n/g, '\n');
 }
 export function getArg(args, key) {

package/dist-lib/lib/tools/exec/obsidian/vault-read.js

@@ -35,14 +35,16 @@ const SEARCH_LIMIT_MAX = 200;
 function parseLimit(args) {
     const raw = getArg(args, 'limit');
     const n = raw ? Number.parseInt(raw, 10) : Number.NaN;
-    if (!Number.isFinite(n) || n <= 0)
+    if (!Number.isFinite(n) || n <= 0) {
         return SEARCH_LIMIT_DEFAULT;
+    }
     return Math.min(n, SEARCH_LIMIT_MAX);
 }
 export function handleSearch(vaultPath, args) {
     const query = getArg(args, 'query');
-    if (!query)
+    if (!query) {
         throw new Error('Missing required argument: query=');
+    }
     const limit = parseLimit(args);
     const lowerQuery = query.toLowerCase();
     const files = listMarkdownFiles(path.resolve(vaultPath));
@@ -52,14 +54,16 @@ export function handleSearch(vaultPath, args) {
             break;
         const fullPath = path.join(path.resolve(vaultPath), relPath);
         try {
-            if (readFileText(fullPath).toLowerCase().includes(lowerQuery))
+            if (readFileText(fullPath).toLowerCase().includes(lowerQuery)) {
                 matches.push(relPath);
+            }
         }
         catch {
         }
     }
-    if (matches.length === 0)
+    if (matches.length === 0) {
         return `No results for "${query}"`;
+    }
     const truncated = matches.length >= limit ? `\n(showing first ${limit}; narrow query for more)` : '';
     return matches.join('\n') + truncated;
 }
@@ -70,19 +74,21 @@ export function handleProperties(vaultPath, args) {
     }
     return JSON.stringify(parseFrontmatter(readFileText(notePath)), null, 2);
 }
+function countTags(tagCounts, content) {
+    for (const match of content.matchAll(/#([a-zA-Z0-9_/-]+)/g)) {
+        const tag = match[1];
+        if (tag === undefined) {
+            continue;
+        }
+        tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
+    }
+}
 export function handleTags(vaultPath) {
     const files = listMarkdownFiles(path.resolve(vaultPath));
     const tagCounts = new Map();
-    const tagRe = /#([a-zA-Z0-9_/-]+)/g;
     for (const relPath of files) {
         try {
-            const content = readFileText(path.join(path.resolve(vaultPath), relPath));
-            for (const match of content.matchAll(tagRe)) {
-                const tag = match[1];
-                if (tag === undefined)
-                    continue;
-                tagCounts.set(tag, (tagCounts.get(tag) || 0) + 1);
-            }
+            countTags(tagCounts, readFileText(path.join(path.resolve(vaultPath), relPath)));
         }
         catch {
         }
@@ -112,8 +118,9 @@ export function handleOutline(vaultPath, args) {
 export function handleDailyRead(vaultPath) {
     const dateStr = todayStamp();
     for (const p of dailyCandidates(vaultPath, dateStr)) {
-        if (fs.existsSync(p))
+        if (fs.existsSync(p)) {
             return readFileText(p);
+        }
     }
     return `No daily note found for ${dateStr}`;
 }

package/dist-lib/lib/tools/exec/obsidian/vault-write.js

@@ -8,8 +8,9 @@ export function handleAppend(vaultPath, args) {
         throw new Error(`Note not found. Args: ${args.join(', ')}`);
     }
     const content = getContentArg(args);
-    if (!content)
+    if (!content) {
         throw new Error('Missing required argument: content=');
+    }
     appendToFile(notePath, content);
     return `Appended to: ${path.relative(vaultPath, notePath)}`;
 }
@@ -19,8 +20,9 @@ export function handlePrepend(vaultPath, args) {
         throw new Error(`Note not found. Args: ${args.join(', ')}`);
     }
     const content = getContentArg(args);
-    if (!content)
+    if (!content) {
         throw new Error('Missing required argument: content=');
+    }
     updateFileText(notePath, (existing) => content + existing);
     return `Prepended to: ${path.relative(vaultPath, notePath)}`;
 }
@@ -30,8 +32,9 @@ function uniqueTrashPath(base) {
     const ext = base.endsWith('.md') ? '.md' : '';
     const stem = ext ? base.slice(0, -ext.length) : base;
     let n = 1;
-    while (fs.existsSync(`${stem} (${n})${ext}`))
+    while (fs.existsSync(`${stem} (${n})${ext}`)) {
         n += 1;
+    }
     return `${stem} (${n})${ext}`;
 }
 export function handleDelete(vaultPath, args) {
@@ -51,11 +54,13 @@ export function handleMove(vaultPath, args) {
         throw new Error(`Note not found. Args: ${args.join(', ')}`);
     }
     const to = getArg(args, 'to');
-    if (!to)
+    if (!to) {
         throw new Error('Missing required argument: to=');
+    }
     const destDir = ensureWithinRoot(vaultPath, to);
-    if (!fs.existsSync(destDir))
+    if (!fs.existsSync(destDir)) {
         fs.mkdirSync(destDir, { recursive: true });
+    }
     const destPath = path.join(destDir, path.basename(notePath));
     moveFile(notePath, destPath);
     return `Moved to: ${path.relative(vaultPath, destPath)}`;
@@ -66,8 +71,9 @@ export function handleRename(vaultPath, args) {
         throw new Error(`Note not found. Args: ${args.join(', ')}`);
     }
     const newName = getArg(args, 'name');
-    if (!newName)
+    if (!newName) {
         throw new Error('Missing required argument: name=');
+    }
     const fileName = markdownFileName(newName);
     const relativeDir = path.relative(path.resolve(vaultPath), path.dirname(notePath));
     const destPath = ensureWithinRoot(vaultPath, path.join(relativeDir, fileName));
@@ -78,10 +84,12 @@ function mergeIntoFrontmatter(fmBlock, newProps) {
     let result = fmBlock;
     for (const { key, value } of newProps) {
         const lineRe = new RegExp(`^${key}:.*$`, 'm');
-        if (lineRe.test(result))
+        if (lineRe.test(result)) {
             result = result.replace(lineRe, `${key}: ${value}`);
-        else
+        }
+        else {
             result += `\n${key}: ${value}`;
+        }
     }
     return result;
 }
@@ -91,8 +99,9 @@ export function handlePropertySet(vaultPath, args) {
         throw new Error(`Note not found. Args: ${args.join(', ')}`);
     }
     const propArgs = args.filter((a) => !a.startsWith('file=') && !a.startsWith('path=') && a.includes('='));
-    if (propArgs.length === 0)
+    if (propArgs.length === 0) {
         throw new Error('No property key=value pairs provided.');
+    }
     const newProps = propArgs.map((a) => {
         const eqIdx = a.indexOf('=');
         return { key: a.slice(0, eqIdx), value: a.slice(eqIdx + 1) };
@@ -110,8 +119,9 @@ export function handlePropertySet(vaultPath, args) {
 }
 export function handleDailyAppend(vaultPath, args) {
     const content = getContentArg(args);
-    if (!content)
+    if (!content) {
         throw new Error('Missing required argument: content=');
+    }
     const dateStr = todayStamp();
     let target = null;
     for (const candidate of dailyCandidates(vaultPath, dateStr)) {
@@ -122,12 +132,14 @@ export function handleDailyAppend(vaultPath, args) {
     }
     if (!target) {
         const dailyDir = ensureWithinRoot(vaultPath, 'Daily Notes');
-        if (!fs.existsSync(dailyDir))
+        if (!fs.existsSync(dailyDir)) {
             fs.mkdirSync(dailyDir, { recursive: true });
+        }
         target = ensureWithinRoot(vaultPath, path.join('Daily Notes', `${dateStr}.md`));
         const snap = readFileSnapshot(target);
-        if (!snap)
+        if (!snap) {
             writeIfUnchanged(target, '', null);
+        }
     }
     appendToFile(target, content);
     return `Appended to daily note: ${dateStr}`;

package/dist-lib/lib/tools/exec/runner.d.ts

@@ -1,29 +1,29 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
-export type ExecAttachment = {
+export interface ExecAttachment {
     readonly attachmentId: string;
     readonly fileName: string;
     readonly byteLength: number;
-};
-export type RejectedOutput = {
+}
+export interface RejectedOutput {
     readonly name: string;
     readonly reason: string;
-};
-export type ExecResult = {
+}
+export interface ExecResult {
     readonly stdout: string;
     readonly stderr: string;
     readonly exitCode: number;
     readonly attachments?: readonly ExecAttachment[];
     readonly missingOutputs?: readonly string[];
     readonly rejectedOutputs?: readonly RejectedOutput[];
-};
-export type SpawnOptions = {
+}
+export interface SpawnOptions {
     cwd?: string;
     shell?: boolean;
     detached?: boolean;
     stdio?: [string, string, string] | string;
     env?: Record<string, string>;
-};
-export type Child = {
+}
+export interface Child {
     readonly pid?: number;
     readonly stdout: {
         on(event: 'data', handler: (chunk: Buffer | string) => void): void;
@@ -34,9 +34,9 @@ export type Child = {
     kill(signum?: number | string): void;
     on(event: 'exit', handler: (code: number | null, signal?: string | null) => void): void;
     on(event: 'error', handler: (err: Error) => void): void;
-};
+}
 export type SpawnFn = (command: string, opts?: SpawnOptions) => Child;
-export type RunCommandOptions = {
+export interface RunCommandOptions {
     readonly cwd?: string;
     readonly env?: Readonly<Record<string, string>>;
     readonly timeoutMs?: number;
@@ -45,15 +45,15 @@ export type RunCommandOptions = {
     readonly spawn: SpawnFn;
     readonly killProcess?: KillProcess;
     readonly platform?: string;
-};
+}
 export declare const MAX_OUTPUT_CHARS = 8192;
 export declare const MAX_OUTPUT_CHARS_LIMIT = 65536;
 export declare const TRUNCATED_OUTPUT_SUFFIX = "\u2026 [truncated]";
 export type KillProcess = (pid: number, signal: string) => void;
-type CapturedOutput = {
+interface CapturedOutput {
     value: string;
     truncated: boolean;
-};
+}
 export declare function capOutput(text: string, limit: number): string;
 export declare function appendOutput(output: CapturedOutput, chunk: Buffer | string, limit: number): void;
 export declare function formatOutput(output: CapturedOutput): string;

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

@@ -1,3 +1,4 @@
+import b4a from 'b4a';
 import process from 'process';
 import { AbortedError } from '../../helpers/race-abort.js';
 const DEFAULT_TIMEOUT_MS = 120_000;
@@ -21,7 +22,7 @@ export function appendOutput(output, chunk, limit) {
         output.truncated = true;
         return;
     }
-    const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+    const text = typeof chunk === 'string' ? chunk : b4a.toString(chunk, 'utf8');
     output.value += text.slice(0, available);
     output.truncated = text.length > available;
 }
@@ -45,8 +46,9 @@ function terminateProcessTree(child, killProcess) {
 export function runCommand(command, options) {
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const maxOutputChars = options.maxOutputChars ?? MAX_OUTPUT_CHARS;
-    if (options.signal?.aborted)
+    if (options.signal?.aborted) {
         return Promise.reject(new AbortedError());
+    }
     return new Promise((resolve, reject) => {
         const stdout = { value: '', truncated: false };
         const stderr = { value: '', truncated: false };
@@ -56,7 +58,7 @@ export function runCommand(command, options) {
             detached: (options.platform ?? process.platform) !== 'win32',
             stdio: ['ignore', 'pipe', 'pipe'],
             cwd: options.cwd,
-            ...(options.env ? { env: { ...options.env } } : {})
+            env: options.env ? { ...options.env } : undefined
         });
         const finish = (fn) => {
             if (settled)

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

@@ -6,8 +6,9 @@ export function bareBin(token) {
 export function firstCommandToken(command) {
     const chars = [...command];
     let i = 0;
-    while (i < chars.length && (chars[i] === ' ' || chars[i] === '\t'))
+    while (i < chars.length && (chars[i] === ' ' || chars[i] === '\t')) {
         i++;
+    }
     let token = '';
     while (i < chars.length) {
         const c = chars[i];
@@ -21,10 +22,12 @@ export function firstCommandToken(command) {
             i++;
             continue;
         }
-        if (c === ' ' || c === '\t' || c === '\n')
+        if (c === ' ' || c === '\t' || c === '\n') {
             break;
-        if (c === ';' || c === '&' || c === '|' || c === '>' || c === '<' || c === '`')
+        }
+        if (c === ';' || c === '&' || c === '|' || c === '>' || c === '<' || c === '`') {
             break;
+        }
         token += c;
         i++;
     }
@@ -33,6 +36,26 @@ export function firstCommandToken(command) {
 function isPad(c) {
     return c === ' ' || c === '\t' || c === '\n';
 }
+function skipDoubleQuoted(chars, open) {
+    let i = open + 1;
+    while (i < chars.length && chars[i] !== '"') {
+        if (chars[i] === '\\') {
+            if (chars[i + 1] === '\n') {
+                return 'command must not use line continuations';
+            }
+            i += 2;
+            continue;
+        }
+        if (chars[i] === '`') {
+            return 'command must not use backtick substitution';
+        }
+        if (chars[i] === '$') {
+            return 'command must not use shell expansion';
+        }
+        i++;
+    }
+    return i + 1;
+}
 export function sanitizeCommand(command) {
     const chars = [...command];
     let i = 0;
@@ -40,57 +63,58 @@ export function sanitizeCommand(command) {
         const c = chars[i];
         if (c === '\n') {
             i++;
-            while (i < chars.length && isPad(chars[i]))
+            while (i < chars.length && isPad(chars[i])) {
                 i++;
-            if (i < chars.length)
+            }
+            if (i < chars.length) {
                 return 'command must not span multiple lines';
+            }
             return null;
         }
         if (c === "'") {
             i++;
-            while (i < chars.length && chars[i] !== "'")
+            while (i < chars.length && chars[i] !== "'") {
                 i++;
+            }
             i++;
             continue;
         }
         if (c === '"') {
-            i++;
-            while (i < chars.length && chars[i] !== '"') {
-                if (chars[i] === '\\') {
-                    if (chars[i + 1] === '\n')
-                        return 'command must not use line continuations';
-                    i += 2;
-                    continue;
-                }
-                if (chars[i] === '`')
-                    return 'command must not use backtick substitution';
-                if (chars[i] === '$')
-                    return 'command must not use shell expansion';
-                i++;
+            const end = skipDoubleQuoted(chars, i);
+            if (typeof end === 'string') {
+                return end;
             }
-            i++;
+            i = end;
             continue;
         }
         if (c === '\\') {
-            if (chars[i + 1] === '\n')
+            if (chars[i + 1] === '\n') {
                 return 'command must not use line continuations';
+            }
             i += 2;
             continue;
         }
-        if (c === '`')
+        if (c === '`') {
             return 'command must not use backtick substitution';
-        if (c === '$')
+        }
+        if (c === '$') {
             return 'command must not use shell expansion';
-        if (c === ';')
+        }
+        if (c === ';') {
             return 'command must not chain with ;';
-        if (c === '&')
+        }
+        if (c === '&') {
             return 'command must not use & or &&';
-        if (c === '|')
+        }
+        if (c === '|') {
             return 'command must not use pipes';
-        if (c === '>')
+        }
+        if (c === '>') {
             return 'command must not redirect output';
-        if (c === '<')
+        }
+        if (c === '<') {
             return 'command must not redirect input';
+        }
         i++;
     }
     return null;

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

@@ -1,36 +1,48 @@
 export function shellEscapeArg(value) {
     return value.replace(/[\\'" \t\n]/g, '\\$&');
 }
+function readQuoted(chars, open) {
+    const quote = chars[open];
+    let text = '';
+    let i = open + 1;
+    while (i < chars.length && chars[i] !== quote) {
+        if (quote === '"' && chars[i] === '\\' && i + 1 < chars.length) {
+            text += chars[i + 1];
+            i += 2;
+            continue;
+        }
+        text += chars[i];
+        i++;
+    }
+    if (i < chars.length) {
+        i++;
+    }
+    return { text, end: i };
+}
 export function shellArgv(command) {
     const chars = [...command];
     const out = [];
     let i = 0;
     while (i < chars.length) {
-        while (i < chars.length && (chars[i] === ' ' || chars[i] === '\t'))
+        while (i < chars.length && (chars[i] === ' ' || chars[i] === '\t')) {
             i++;
-        if (i >= chars.length)
+        }
+        if (i >= chars.length) {
             break;
-        if (chars[i] === '\n')
+        }
+        if (chars[i] === '\n') {
             break;
+        }
         let token = '';
         while (i < chars.length) {
             const c = chars[i];
-            if (c === ' ' || c === '\t' || c === '\n')
+            if (c === ' ' || c === '\t' || c === '\n') {
                 break;
+            }
             if (c === "'" || c === '"') {
-                const quote = c;
-                i++;
-                while (i < chars.length && chars[i] !== quote) {
-                    if (quote === '"' && chars[i] === '\\' && i + 1 < chars.length) {
-                        token += chars[i + 1];
-                        i += 2;
-                        continue;
-                    }
-                    token += chars[i];
-                    i++;
-                }
-                if (i < chars.length)
-                    i++;
+                const quoted = readQuoted(chars, i);
+                token += quoted.text;
+                i = quoted.end;
                 continue;
             }
             if (c === '\\' && i + 1 < chars.length) {
@@ -41,8 +53,9 @@ export function shellArgv(command) {
             token += c;
             i++;
         }
-        if (token.length > 0 || out.length > 0)
+        if (token.length > 0 || out.length > 0) {
             out.push(token);
+        }
     }
     return out;
 }

package/dist-lib/lib/tools/exec/shell-guidance.d.ts

@@ -1,7 +1,12 @@
 export declare const PYTHON_BIN_ERROR: string;
 export declare const PACKAGES_NEED_PYTHON_ERROR: string;
 export declare const FILES_NEED_PYTHON_ERROR: string;
-export declare function videoToolError(command: string, packages: readonly string[] | undefined, python: boolean, network?: boolean): string | null;
+export interface VideoToolCall {
+    packages?: readonly string[] | undefined;
+    python: boolean;
+    network?: boolean;
+}
+export declare function videoToolError(command: string, { packages, python, network }: VideoToolCall): string | null;
 export declare const SHELL_DOWNLOAD_NOTE: string;
 export declare function shellDownloadNote(command: string): string | null;
 export declare function pipError(command: string, sandbox?: boolean): string | null;