@geminilight/mindos 0.5.20 → 0.5.21

package/app/lib/agent/tools.ts

@@ -1,13 +1,11 @@
-import { tool } from 'ai';
-import { z } from 'zod';
+import { Type, type Static } from '@sinclair/typebox';
+import type { AgentTool, AgentToolResult } from '@mariozechner/pi-agent-core';
 import {
   searchFiles, getFileContent, getFileTree, getRecentlyModified,
   saveFileContent, createFile, appendToFile, insertAfterHeading, updateSection,
   deleteFile, renameFile, moveFile, findBacklinks, gitLog, gitShowFile, appendCsvRow,
   getMindRoot,
 } from '@/lib/fs';
-import { assertNotProtected } from '@/lib/core';
-import { logAgentOp } from './log';
 
 // Max chars per file to avoid token overflow (~100k chars ≈ ~25k tokens)
 const MAX_FILE_CHARS = 20_000;
@@ -17,329 +15,325 @@ export function truncate(content: string): string {
   return content.slice(0, MAX_FILE_CHARS) + `\n\n[...truncated — file is ${content.length} chars, showing first ${MAX_FILE_CHARS}]`;
 }
 
-/** Checks write-protection using core's assertNotProtected */
-export function assertWritable(filePath: string): void {
-  assertNotProtected(filePath, 'modified by AI agent');
+// ─── Helper: format tool error consistently ────────────────────────────────
+
+function formatToolError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// ─── Helper: build a text-only AgentToolResult ──────────────────────────────
+
+function textResult(text: string): AgentToolResult<Record<string, never>> {
+  return { content: [{ type: 'text', text }], details: {} as Record<string, never> };
 }
 
-/**
- * Wrap a tool execute fn with agent-op logging.
- * Catches ALL exceptions and returns an error string — never throws.
- * This is critical: an unhandled throw from a tool execute function kills
- * the AI SDK stream and corrupts the session message state, causing
- * "Cannot read properties of undefined" on every subsequent request.
- */
-function logged<P extends Record<string, unknown>>(
-  toolName: string,
-  fn: (params: P) => Promise<string>,
-): (params: P) => Promise<string> {
-  return async (params: P) => {
-    const ts = new Date().toISOString();
+/** Safe execute wrapper — catches all errors, returns error text (never throws) */
+function safeExecute<T>(
+  fn: (toolCallId: string, params: T, signal?: AbortSignal) => Promise<AgentToolResult<any>>,
+): (toolCallId: string, params: T, signal?: AbortSignal) => Promise<AgentToolResult<any>> {
+  return async (toolCallId, params, signal) => {
     try {
-      const result = await fn(params);
-      const isError = result.startsWith('Error:');
-      try { logAgentOp({ ts, tool: toolName, params, result: isError ? 'error' : 'ok', message: result.slice(0, 200) }); } catch { /* logging must never kill the stream */ }
-      return result;
+      return await fn(toolCallId, params, signal);
     } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      try { logAgentOp({ ts, tool: toolName, params, result: 'error', message: msg.slice(0, 200) }); } catch { /* swallow — logging must never kill the stream */ }
-      return `Error: ${msg}`;
+      return textResult(`Error: ${formatToolError(e)}`);
     }
   };
 }
 
-// ─── Knowledge base tools ─────────────────────────────────────────────────────
+// ─── TypeBox Schemas ────────────────────────────────────────────────────────
+
+const ListFilesParams = Type.Object({
+  path: Type.Optional(Type.String({ description: 'Optional subdirectory to list (e.g. "Projects/Products"). Omit to list everything.' })),
+  depth: Type.Optional(Type.Number({ description: 'Max tree depth to expand (default 3). Directories deeper than this show item count only.', minimum: 1, maximum: 10 })),
+});
+
+const PathParam = Type.Object({
+  path: Type.String({ description: 'Relative file path' }),
+});
+
+const QueryParam = Type.Object({
+  query: Type.String({ description: 'Search query (case-insensitive)' }),
+});
+
+const LimitParam = Type.Object({
+  limit: Type.Optional(Type.Number({ description: 'Number of files to return (default 10)', minimum: 1, maximum: 50 })),
+});
+
+const WriteFileParams = Type.Object({
+  path: Type.String({ description: 'Relative file path' }),
+  content: Type.String({ description: 'New full content' }),
+});
+
+const CreateFileParams = Type.Object({
+  path: Type.String({ description: 'Relative file path (must end in .md or .csv)' }),
+  content: Type.Optional(Type.String({ description: 'Initial file content' })),
+});
+
+const AppendParams = Type.Object({
+  path: Type.String({ description: 'Relative file path' }),
+  content: Type.String({ description: 'Content to append' }),
+});
+
+const InsertHeadingParams = Type.Object({
+  path: Type.String({ description: 'Relative file path' }),
+  heading: Type.String({ description: 'Heading text to find (e.g. "## Tasks" or just "Tasks")' }),
+  content: Type.String({ description: 'Content to insert after the heading' }),
+});
+
+const UpdateSectionParams = Type.Object({
+  path: Type.String({ description: 'Relative file path' }),
+  heading: Type.String({ description: 'Heading text to find (e.g. "## Status")' }),
+  content: Type.String({ description: 'New content for the section' }),
+});
+
+const RenameParams = Type.Object({
+  path: Type.String({ description: 'Current relative file path' }),
+  new_name: Type.String({ description: 'New filename (no path separators, e.g. "new-name.md")' }),
+});
 
-export const knowledgeBaseTools = {
-  list_files: tool({
+const MoveParams = Type.Object({
+  from_path: Type.String({ description: 'Current relative file path' }),
+  to_path: Type.String({ description: 'New relative file path' }),
+});
+
+const HistoryParams = Type.Object({
+  path: Type.String({ description: 'Relative file path' }),
+  limit: Type.Optional(Type.Number({ description: 'Number of commits to return (default 10)', minimum: 1, maximum: 50 })),
+});
+
+const FileAtVersionParams = Type.Object({
+  path: Type.String({ description: 'Relative file path' }),
+  commit: Type.String({ description: 'Git commit hash (full or abbreviated)' }),
+});
+
+const CsvAppendParams = Type.Object({
+  path: Type.String({ description: 'Relative path to .csv file' }),
+  row: Type.Array(Type.String(), { description: 'Array of cell values for the new row' }),
+});
+
+// ─── Tool Definitions (AgentTool interface) ─────────────────────────────────
+
+// Write-operation tool names — used by beforeToolCall for write-protection
+export const WRITE_TOOLS = new Set([
+  'write_file', 'create_file', 'append_to_file', 'insert_after_heading',
+  'update_section', 'delete_file', 'rename_file', 'move_file', 'append_csv',
+]);
+
+export const knowledgeBaseTools: AgentTool<any>[] = [
+  {
+    name: 'list_files',
+    label: 'List Files',
     description: 'List files in the knowledge base as an indented tree. Directories beyond `depth` show "... (N items)". Pass `path` to list only a subdirectory, or `depth` to control how deep to expand (default 3).',
-    inputSchema: z.object({
-      path: z.string().nullish().describe('Optional subdirectory to list (e.g. "Projects/Products"). Omit to list everything.'),
-      depth: z.number().min(1).max(10).nullish().describe('Max tree depth to expand (default 3). Directories deeper than this show item count only.'),
-    }),
-    execute: logged('list_files', async ({ path: subdir, depth: maxDepth }) => {
-      try {
-        const tree = getFileTree();
-
-        // Empty tree at root level → likely a misconfigured mindRoot
-        if (tree.length === 0 && !subdir) {
-          const root = getMindRoot();
-          return `(empty — no .md or .csv files found under mind_root: ${root})`;
-        }
+    parameters: ListFilesParams,
+    execute: safeExecute(async (_id, params: Static<typeof ListFilesParams>) => {
+      const { path: subdir, depth: maxDepth } = params;
+      const tree = getFileTree();
+
+      if (tree.length === 0 && !subdir) {
+        const root = getMindRoot();
+        return textResult(`(empty — no .md or .csv files found under mind_root: ${root})`);
+      }
 
-        const limit = maxDepth ?? 3;
-        const lines: string[] = [];
-        function walk(nodes: Array<{ name: string; type: string; children?: unknown[] }>, depth: number) {
-          for (const n of nodes) {
-            lines.push('  '.repeat(depth) + (n.type === 'directory' ? `${n.name}/` : n.name));
-            if (n.type === 'directory' && Array.isArray(n.children)) {
-              if (depth + 1 < limit) {
-                walk(n.children as typeof nodes, depth + 1);
-              } else {
-                lines.push('  '.repeat(depth + 1) + `... (${n.children.length} items)`);
-              }
+      const limit = maxDepth ?? 3;
+      const lines: string[] = [];
+      function walk(nodes: Array<{ name: string; type: string; children?: unknown[] }>, depth: number) {
+        for (const n of nodes) {
+          lines.push('  '.repeat(depth) + (n.type === 'directory' ? `${n.name}/` : n.name));
+          if (n.type === 'directory' && Array.isArray(n.children)) {
+            if (depth + 1 < limit) {
+              walk(n.children as typeof nodes, depth + 1);
+            } else {
+              lines.push('  '.repeat(depth + 1) + `... (${n.children.length} items)`);
             }
           }
         }
+      }
 
-        if (subdir) {
-          const segments = subdir.replace(/\/$/, '').split('/').filter(Boolean);
-          let current: Array<{ name: string; type: string; path?: string; children?: unknown[] }> = tree as any;
-          for (const seg of segments) {
-            const found = current.find(n => n.name === seg && n.type === 'directory');
-            if (!found || !Array.isArray(found.children)) {
-              return `Directory not found: ${subdir}`;
-            }
-            current = found.children as typeof current;
+      if (subdir) {
+        const segments = subdir.replace(/\/$/, '').split('/').filter(Boolean);
+        let current: Array<{ name: string; type: string; path?: string; children?: unknown[] }> = tree as any;
+        for (const seg of segments) {
+          const found = current.find(n => n.name === seg && n.type === 'directory');
+          if (!found || !Array.isArray(found.children)) {
+            return textResult(`Directory not found: ${subdir}`);
           }
-          walk(current as any, 0);
-        } else {
-          walk(tree as any, 0);
+          current = found.children as typeof current;
         }
-
-        return lines.length > 0 ? lines.join('\n') : '(empty directory)';
-      } catch (e: unknown) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`;
+        walk(current as any, 0);
+      } else {
+        walk(tree as any, 0);
       }
+
+      return textResult(lines.length > 0 ? lines.join('\n') : '(empty directory)');
     }),
-  }),
+  },
 
-  read_file: tool({
+  {
+    name: 'read_file',
+    label: 'Read File',
     description: 'Read the content of a file by its relative path. Always read a file before modifying it.',
-    inputSchema: z.object({ path: z.string().describe('Relative file path, e.g. "Profile/👤 Identity.md"') }),
-    execute: logged('read_file', async ({ path }) => {
-      try {
-        return truncate(getFileContent(path));
-      } catch (e: unknown) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`;
-      }
+    parameters: PathParam,
+    execute: safeExecute(async (_id, params: Static<typeof PathParam>) => {
+      return textResult(truncate(getFileContent(params.path)));
     }),
-  }),
+  },
 
-  search: tool({
+  {
+    name: 'search',
+    label: 'Search',
     description: 'Full-text search across all files in the knowledge base. Returns matching files with context snippets.',
-    inputSchema: z.object({ query: z.string().describe('Search query (case-insensitive)') }),
-    execute: logged('search', async ({ query }) => {
-      const results = searchFiles(query);
-      if (results.length === 0) return 'No results found.';
-      return results.map(r => `- **${r.path}**: ${r.snippet}`).join('\n');
+    parameters: QueryParam,
+    execute: safeExecute(async (_id, params: Static<typeof QueryParam>) => {
+      const results = searchFiles(params.query);
+      if (results.length === 0) return textResult('No results found.');
+      return textResult(results.map(r => `- **${r.path}**: ${r.snippet}`).join('\n'));
     }),
-  }),
+  },
 
-  get_recent: tool({
+  {
+    name: 'get_recent',
+    label: 'Recent Files',
     description: 'Get the most recently modified files in the knowledge base.',
-    inputSchema: z.object({ limit: z.number().min(1).max(50).nullish().describe('Number of files to return (default 10)') }),
-    execute: logged('get_recent', async ({ limit }) => {
-      const files = getRecentlyModified(limit ?? 10);
-      return files.map(f => `- ${f.path} (${new Date(f.mtime).toISOString()})`).join('\n');
+    parameters: LimitParam,
+    execute: safeExecute(async (_id, params: Static<typeof LimitParam>) => {
+      const files = getRecentlyModified(params.limit ?? 10);
+      return textResult(files.map(f => `- ${f.path} (${new Date(f.mtime).toISOString()})`).join('\n'));
     }),
-  }),
+  },
 
-  write_file: tool({
+  {
+    name: 'write_file',
+    label: 'Write File',
     description: 'Overwrite the entire content of an existing file. Use read_file first to see current content. Prefer update_section or insert_after_heading for partial edits.',
-    inputSchema: z.object({
-      path: z.string().describe('Relative file path'),
-      content: z.string().describe('New full content'),
-    }),
-    execute: logged('write_file', async ({ path, content }) => {
-      try {
-        assertWritable(path);
-        saveFileContent(path, content);
-        return `File written: ${path}`;
-      } catch (e: unknown) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`;
-      }
+    parameters: WriteFileParams,
+    execute: safeExecute(async (_id, params: Static<typeof WriteFileParams>) => {
+      saveFileContent(params.path, params.content);
+      return textResult(`File written: ${params.path}`);
     }),
-  }),
+  },
 
-  create_file: tool({
+  {
+    name: 'create_file',
+    label: 'Create File',
     description: 'Create a new file. Only .md and .csv files are allowed. Parent directories are created automatically.',
-    inputSchema: z.object({
-      path: z.string().describe('Relative file path (must end in .md or .csv)'),
-      content: z.string().nullish().describe('Initial file content'),
+    parameters: CreateFileParams,
+    execute: safeExecute(async (_id, params: Static<typeof CreateFileParams>) => {
+      createFile(params.path, params.content ?? '');
+      return textResult(`File created: ${params.path}`);
     }),
-    execute: logged('create_file', async ({ path, content }) => {
-      try {
-        assertWritable(path);
-        createFile(path, content ?? '');
-        return `File created: ${path}`;
-      } catch (e: unknown) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`;
-      }
-    }),
-  }),
+  },
 
-  append_to_file: tool({
+  {
+    name: 'append_to_file',
+    label: 'Append to File',
     description: 'Append text to the end of an existing file. A blank line separator is added automatically.',
-    inputSchema: z.object({
-      path: z.string().describe('Relative file path'),
-      content: z.string().describe('Content to append'),
-    }),
-    execute: logged('append_to_file', async ({ path, content }) => {
-      try {
-        assertWritable(path);
-        appendToFile(path, content);
-        return `Content appended to: ${path}`;
-      } catch (e: unknown) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`;
-      }
+    parameters: AppendParams,
+    execute: safeExecute(async (_id, params: Static<typeof AppendParams>) => {
+      appendToFile(params.path, params.content);
+      return textResult(`Content appended to: ${params.path}`);
     }),
-  }),
+  },
 
-  insert_after_heading: tool({
+  {
+    name: 'insert_after_heading',
+    label: 'Insert After Heading',
     description: 'Insert content right after a Markdown heading. Useful for adding items under a specific section.',
-    inputSchema: z.object({
-      path: z.string().describe('Relative file path'),
-      heading: z.string().describe('Heading text to find (e.g. "## Tasks" or just "Tasks")'),
-      content: z.string().describe('Content to insert after the heading'),
-    }),
-    execute: logged('insert_after_heading', async ({ path, heading, content }) => {
-      try {
-        assertWritable(path);
-        insertAfterHeading(path, heading, content);
-        return `Content inserted after heading "${heading}" in ${path}`;
-      } catch (e: unknown) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`;
-      }
+    parameters: InsertHeadingParams,
+    execute: safeExecute(async (_id, params: Static<typeof InsertHeadingParams>) => {
+      insertAfterHeading(params.path, params.heading, params.content);
+      return textResult(`Content inserted after heading "${params.heading}" in ${params.path}`);
     }),
-  }),
+  },
 
-  update_section: tool({
+  {
+    name: 'update_section',
+    label: 'Update Section',
     description: 'Replace the content of a Markdown section identified by its heading. The section spans from the heading to the next heading of equal or higher level.',
-    inputSchema: z.object({
-      path: z.string().describe('Relative file path'),
-      heading: z.string().describe('Heading text to find (e.g. "## Status")'),
-      content: z.string().describe('New content for the section'),
+    parameters: UpdateSectionParams,
+    execute: safeExecute(async (_id, params: Static<typeof UpdateSectionParams>) => {
+      updateSection(params.path, params.heading, params.content);
+      return textResult(`Section "${params.heading}" updated in ${params.path}`);
     }),
-    execute: logged('update_section', async ({ path, heading, content }) => {
-      try {
-        assertWritable(path);
-        updateSection(path, heading, content);
-        return `Section "${heading}" updated in ${path}`;
-      } catch (e: unknown) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`;
-      }
-    }),
-  }),
-
-  // ─── New tools (Phase 1a) ──────────────────────────────────────────────────
+  },
 
-  delete_file: tool({
+  {
+    name: 'delete_file',
+    label: 'Delete File',
     description: 'Permanently delete a file from the knowledge base. This is destructive and cannot be undone.',
-    inputSchema: z.object({
-      path: z.string().describe('Relative file path to delete'),
+    parameters: PathParam,
+    execute: safeExecute(async (_id, params: Static<typeof PathParam>) => {
+      deleteFile(params.path);
+      return textResult(`File deleted: ${params.path}`);
     }),
-    execute: logged('delete_file', async ({ path }) => {
-      try {
-        assertWritable(path);
-        deleteFile(path);
-        return `File deleted: ${path}`;
-      } catch (e: unknown) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`;
-      }
-    }),
-  }),
+  },
 
-  rename_file: tool({
+  {
+    name: 'rename_file',
+    label: 'Rename File',
     description: 'Rename a file within its current directory. Only the filename changes, not the directory.',
-    inputSchema: z.object({
-      path: z.string().describe('Current relative file path'),
-      new_name: z.string().describe('New filename (no path separators, e.g. "new-name.md")'),
-    }),
-    execute: logged('rename_file', async ({ path, new_name }) => {
-      try {
-        assertWritable(path);
-        const newPath = renameFile(path, new_name);
-        return `File renamed: ${path} → ${newPath}`;
-      } catch (e: unknown) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`;
-      }
+    parameters: RenameParams,
+    execute: safeExecute(async (_id, params: Static<typeof RenameParams>) => {
+      const newPath = renameFile(params.path, params.new_name);
+      return textResult(`File renamed: ${params.path} → ${newPath}`);
     }),
-  }),
+  },
 
-  move_file: tool({
+  {
+    name: 'move_file',
+    label: 'Move File',
     description: 'Move a file to a new location. Also returns any files that had backlinks affected by the move.',
-    inputSchema: z.object({
-      from_path: z.string().describe('Current relative file path'),
-      to_path: z.string().describe('New relative file path'),
+    parameters: MoveParams,
+    execute: safeExecute(async (_id, params: Static<typeof MoveParams>) => {
+      const result = moveFile(params.from_path, params.to_path);
+      const affected = result.affectedFiles.length > 0
+        ? `\nAffected backlinks in: ${result.affectedFiles.join(', ')}`
+        : '';
+      return textResult(`File moved: ${params.from_path} → ${result.newPath}${affected}`);
     }),
-    execute: logged('move_file', async ({ from_path, to_path }) => {
-      try {
-        assertWritable(from_path);
-        const result = moveFile(from_path, to_path);
-        const affected = result.affectedFiles.length > 0
-          ? `\nAffected backlinks in: ${result.affectedFiles.join(', ')}`
-          : '';
-        return `File moved: ${from_path} → ${result.newPath}${affected}`;
-      } catch (e: unknown) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`;
-      }
-    }),
-  }),
+  },
 
-  get_backlinks: tool({
+  {
+    name: 'get_backlinks',
+    label: 'Backlinks',
     description: 'Find all files that reference a given file path. Useful for understanding connections between notes.',
-    inputSchema: z.object({
-      path: z.string().describe('Relative file path to find backlinks for'),
-    }),
-    execute: logged('get_backlinks', async ({ path }) => {
-      try {
-        const backlinks = findBacklinks(path);
-        if (backlinks.length === 0) return `No backlinks found for: ${path}`;
-        return backlinks.map(b => `- **${b.source}** (L${b.line}): ${b.context}`).join('\n');
-      } catch (e: unknown) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`;
-      }
+    parameters: PathParam,
+    execute: safeExecute(async (_id, params: Static<typeof PathParam>) => {
+      const backlinks = findBacklinks(params.path);
+      if (backlinks.length === 0) return textResult(`No backlinks found for: ${params.path}`);
+      return textResult(backlinks.map(b => `- **${b.source}** (L${b.line}): ${b.context}`).join('\n'));
     }),
-  }),
+  },
 
-  get_history: tool({
+  {
+    name: 'get_history',
+    label: 'History',
     description: 'Get git commit history for a file. Shows recent commits that modified this file.',
-    inputSchema: z.object({
-      path: z.string().describe('Relative file path'),
-      limit: z.number().min(1).max(50).nullish().describe('Number of commits to return (default 10)'),
+    parameters: HistoryParams,
+    execute: safeExecute(async (_id, params: Static<typeof HistoryParams>) => {
+      const commits = gitLog(params.path, params.limit ?? 10);
+      if (commits.length === 0) return textResult(`No git history found for: ${params.path}`);
+      return textResult(commits.map(c => `- \`${c.hash.slice(0, 7)}\` ${c.date} — ${c.message} (${c.author})`).join('\n'));
     }),
-    execute: logged('get_history', async ({ path, limit }) => {
-      try {
-        const commits = gitLog(path, limit ?? 10);
-        if (commits.length === 0) return `No git history found for: ${path}`;
-        return commits.map(c => `- \`${c.hash.slice(0, 7)}\` ${c.date} — ${c.message} (${c.author})`).join('\n');
-      } catch (e: unknown) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`;
-      }
-    }),
-  }),
+  },
 
-  get_file_at_version: tool({
+  {
+    name: 'get_file_at_version',
+    label: 'File at Version',
     description: 'Read the content of a file at a specific git commit. Use get_history first to find commit hashes.',
-    inputSchema: z.object({
-      path: z.string().describe('Relative file path'),
-      commit: z.string().describe('Git commit hash (full or abbreviated)'),
-    }),
-    execute: logged('get_file_at_version', async ({ path, commit }) => {
-      try {
-        const content = gitShowFile(path, commit);
-        return truncate(content);
-      } catch (e: unknown) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`;
-      }
+    parameters: FileAtVersionParams,
+    execute: safeExecute(async (_id, params: Static<typeof FileAtVersionParams>) => {
+      return textResult(truncate(gitShowFile(params.path, params.commit)));
     }),
-  }),
+  },
 
-  append_csv: tool({
+  {
+    name: 'append_csv',
+    label: 'Append CSV Row',
     description: 'Append a row to a CSV file. Values are automatically escaped per RFC 4180.',
-    inputSchema: z.object({
-      path: z.string().describe('Relative path to .csv file'),
-      row: z.array(z.string()).describe('Array of cell values for the new row'),
-    }),
-    execute: logged('append_csv', async ({ path, row }) => {
-      try {
-        assertWritable(path);
-        const result = appendCsvRow(path, row);
-        return `Row appended to ${path} (now ${result.newRowCount} rows)`;
-      } catch (e: unknown) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`;
-      }
+    parameters: CsvAppendParams,
+    execute: safeExecute(async (_id, params: Static<typeof CsvAppendParams>) => {
+      const result = appendCsvRow(params.path, params.row);
+      return textResult(`Row appended to ${params.path} (now ${result.newRowCount} rows)`);
     }),
-  }),
-};
+  },
+];