Merge pull request #1 from VaiYav/chore/dependency-updates

feat: reconcile roadmap implementation wave

Author: VaiYav

.agents/skills/swarm/scripts/batching.ts

@@ -169,10 +169,7 @@ function formatValue(value: unknown): string {
  * sees a column name as a name, never as template syntax.
  */
 function renderTaskBlock(instruction: string): string {
-  return instruction.replace(
-    /\{([^}]+)\}/g,
-    (_m, raw) => `\`${String(raw).trim()}\``,
-  );
+  return instruction.replace(/\{([^}]+)\}/g, (_m, raw) => `\`${String(raw).trim()}\``);
 }
 
 /**
@@ -185,10 +182,7 @@ function renderTaskBlock(instruction: string): string {
  *       col1: <value>
  *       col2: <value>
  */
-function renderItemsBlock(
-  rows: Array<Record<string, unknown>>,
-  placeholders: string[],
-): string {
+function renderItemsBlock(rows: Array<Record<string, unknown>>, placeholders: string[]): string {
   const lines: string[] = [];
 
   for (const row of rows) {

.agents/skills/swarm/scripts/executor.ts

@@ -39,9 +39,7 @@ export async function callTask(args: {
   mode?: "agent" | "invoke";
 }): Promise<string> {
   if (typeof tools.swarmTask !== "function") {
-    throw new Error(
-      "Swarm requires a 'swarm_task' tool in the PTC configuration.",
-    );
+    throw new Error("Swarm requires a 'swarm_task' tool in the PTC configuration.");
   }
   return tools.swarmTask(args);
 }
@@ -148,10 +146,7 @@ export function deduplicateFailures(results: TaskResult[]): FailureGroup[] {
  * @param row - The table row to update (mutated in place).
  * @param value - The subagent's parsed structured output.
  */
-export function mergeResult(
-  row: Record<string, unknown>,
-  value: Record<string, unknown>,
-): void {
+export function mergeResult(row: Record<string, unknown>, value: Record<string, unknown>): void {
   for (const [k, v] of Object.entries(value)) {
     if (!RESERVED_COLUMNS.has(k)) {
       row[k] = v;

.agents/skills/swarm/scripts/filter.ts

@@ -34,14 +34,9 @@ function deepEquals(a: unknown, b: unknown): boolean {
  * @param row - The table row to test against.
  * @returns `true` if the row matches the filter.
  */
-export function evaluateFilter(
-  filter: SwarmFilter,
-  row: Record<string, unknown>,
-): boolean {
+export function evaluateFilter(filter: SwarmFilter, row: Record<string, unknown>): boolean {
   if (filter == null || typeof filter !== "object") {
-    throw new Error(
-      `evaluateFilter: expected a filter object, got ${JSON.stringify(filter)}`,
-    );
+    throw new Error(`evaluateFilter: expected a filter object, got ${JSON.stringify(filter)}`);
   }
 
   if ("and" in filter) {

.agents/skills/swarm/scripts/index.ts

@@ -120,10 +120,7 @@ function buildDispatchUnits(
  * Single-row units pass through directly. Batch units are unpacked
  * into one result per row — missing rows become failures.
  */
-function unpackDispatchResults(
-  units: DispatchUnit[],
-  results: TaskResult[],
-): TaskResult[] {
+function unpackDispatchResults(units: DispatchUnit[], results: TaskResult[]): TaskResult[] {
   const rowResults: TaskResult[] = [];
 
   for (let idx = 0; idx < units.length; idx++) {
@@ -142,10 +139,7 @@ function unpackDispatchResults(
       continue;
     }
 
-    const { results: unpacked } = unpackBatchResults(
-      result.result ?? "",
-      unit.rowIds,
-    );
+    const { results: unpacked } = unpackBatchResults(result.result ?? "", unit.rowIds);
     for (const rowId of unit.rowIds) {
       const value = unpacked.get(rowId);
       if (value !== undefined) {
@@ -206,21 +200,14 @@ function mergeRowResults(
  * Verify every `{column}` reference in `instruction` resolves on at
  * least one matched row. Throws with a list of unresolved paths.
  */
-function validatePlaceholders(
-  instruction: string,
-  rows: Record<string, unknown>[],
-): void {
+function validatePlaceholders(instruction: string, rows: Record<string, unknown>[]): void {
   const placeholders = extractPlaceholders(instruction);
   if (placeholders.length === 0) {
     return;
   }
-  const unresolved = placeholders.filter(
-    (p) => !rows.some((r) => readColumn(r, p) !== undefined),
-  );
+  const unresolved = placeholders.filter((p) => !rows.some((r) => readColumn(r, p) !== undefined));
   if (unresolved.length > 0) {
-    throw new Error(
-      `instruction references unknown column(s): ${unresolved.join(", ")}`,
-    );
+    throw new Error(`instruction references unknown column(s): ${unresolved.join(", ")}`);
   }
 }
 
@@ -249,26 +236,13 @@ export async function create(source: CreateSource): Promise<SwarmHandle> {
  * @param options - Dispatch configuration (instruction, filter, schema, etc.).
  * @returns A summary with completion counts and deduplicated failure groups.
  */
-export async function run(
-  tableId: string,
-  options: RunOptions,
-): Promise<RunResult> {
+export async function run(tableId: string, options: RunOptions): Promise<RunResult> {
   const allRows = await loadTable(tableId);
-  const {
-    instruction,
-    context,
-    filter,
-    subagentType,
-    responseSchema,
-    batchSize,
-    concurrency,
-  } = options;
+  const { instruction, context, filter, subagentType, responseSchema, batchSize, concurrency } =
+    options;
   const mode = subagentType != null ? "agent" : "invoke";
 
-  const effectiveConcurrency = Math.max(
-    1,
-    Math.min(concurrency ?? MAX_SUBAGENTS, MAX_SUBAGENTS),
-  );
+  const effectiveConcurrency = Math.max(1, Math.min(concurrency ?? MAX_SUBAGENTS, MAX_SUBAGENTS));
 
   // -----------------------------------------------------------------------
   // 1. Partition rows into matched (dispatched) and skipped (filtered out)
@@ -329,10 +303,7 @@ export async function run(
   }
 
   const rowResults = unpackDispatchResults(units, dispatchResults);
-  const { completed, failed: mergeFailed } = mergeRowResults(
-    rowResults,
-    rowById,
-  );
+  const { completed, failed: mergeFailed } = mergeRowResults(rowResults, rowById);
   const failed = mergeFailed + interpolationErrors.length;
   const allRowResults = [...interpolationErrors, ...rowResults];
 

.agents/skills/swarm/scripts/interpolate.ts

@@ -17,10 +17,7 @@ import { readColumn } from "./utils.js";
  * @returns The interpolated string with all placeholders resolved.
  * @throws Error listing all missing column paths.
  */
-export function interpolate(
-  template: string,
-  row: Record<string, unknown>,
-): string {
+export function interpolate(template: string, row: Record<string, unknown>): string {
   const missing: string[] = [];
 
   const result = template.replace(/\{([^}]+)\}/g, (_match, rawPath) => {
@@ -44,9 +41,7 @@ export function interpolate(
   });
 
   if (missing.length > 0) {
-    throw new Error(
-      `Interpolation failed: missing columns: ${missing.join(", ")}`,
-    );
+    throw new Error(`Interpolation failed: missing columns: ${missing.join(", ")}`);
   }
 
   return result;

.agents/skills/swarm/scripts/table.ts

@@ -138,19 +138,14 @@ export function parseJsonl(content: string): Record<string, unknown>[] {
   const parseLine = (line: string, idx: number): Record<string, unknown> => {
     try {
       const parsed = JSON.parse(line);
-      if (
-        typeof parsed !== "object" ||
-        parsed === null ||
-        Array.isArray(parsed)
-      ) {
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
         throw new Error(`expected object`);
       }
       return parsed as Record<string, unknown>;
     } catch (e) {
-      throw new Error(
-        `JSONL parse error at line ${idx + 1}: ${(e as Error).message}`,
-        { cause: e },
-      );
+      throw new Error(`JSONL parse error at line ${idx + 1}: ${(e as Error).message}`, {
+        cause: e,
+      });
     }
   };
 
@@ -195,9 +190,7 @@ export function extractSeqFromPath(filePath: string): number {
  * @param paths - List of file paths.
  * @returns Array of `{ id, file }` row objects.
  */
-export function pathsToRows(
-  paths: string[],
-): Array<{ id: string; file: string }> {
+export function pathsToRows(paths: string[]): Array<{ id: string; file: string }> {
   const basenames = paths.map((p) => {
     const parts = p.split("/");
     return parts[parts.length - 1] || p;
@@ -286,9 +279,7 @@ export async function globFiles(pattern: string): Promise<string[]> {
  */
 export async function readFile(path: string): Promise<string> {
   if (typeof tools.readFile !== "function") {
-    throw new Error(
-      `Swarm requires a 'readFile' tool in the PTC configuration`,
-    );
+    throw new Error(`Swarm requires a 'readFile' tool in the PTC configuration`);
   }
   return tools.readFile({ file_path: path });
 }
@@ -315,16 +306,12 @@ export async function writeFile(
   previousContent?: string,
 ): Promise<void> {
   if (typeof tools.writeFile !== "function") {
-    throw new Error(
-      `Swarm requires a 'writeFile' tool in the PTC configuration`,
-    );
+    throw new Error(`Swarm requires a 'writeFile' tool in the PTC configuration`);
   }
   const result = await tools.writeFile({ file_path: path, content });
   if (typeof result === "string" && result.includes("already exists")) {
     if (typeof tools.editFile !== "function") {
-      throw new Error(
-        "Swarm requires an 'edit_file' PTC tool to update existing tables",
-      );
+      throw new Error("Swarm requires an 'edit_file' PTC tool to update existing tables");
     }
     if (previousContent == null) {
       throw new Error(
@@ -438,14 +425,10 @@ async function resolveGlob(pattern: string | string[]): Promise<string[]> {
  * @throws Error if the source is invalid, empty, or missing required PTC tools.
  */
 export async function createTable(source: CreateSource): Promise<SwarmHandle> {
-  const sourceCount = [source.glob, source.filePaths, source.tasks].filter(
-    (s) => s != null,
-  ).length;
+  const sourceCount = [source.glob, source.filePaths, source.tasks].filter((s) => s != null).length;
 
   if (sourceCount === 0) {
-    throw new Error(
-      "create() requires exactly one source: glob, filePaths, or tasks",
-    );
+    throw new Error("create() requires exactly one source: glob, filePaths, or tasks");
   }
 
   if (sourceCount > 1) {
@@ -510,9 +493,7 @@ export async function createTable(source: CreateSource): Promise<SwarmHandle> {
  * @returns The table's row array (by reference — mutations are visible).
  * @throws Error if the table is not found (evicted or never created).
  */
-export async function loadTable(
-  id: string,
-): Promise<Record<string, unknown>[]> {
+export async function loadTable(id: string): Promise<Record<string, unknown>[]> {
   const cached = cache.get(id);
   if (cached) {
     return cached.rows;
@@ -546,10 +527,7 @@ export async function loadTable(
  * @param rows - The updated row array to persist.
  * @throws Error if the table has not been loaded into cache.
  */
-export async function saveTable(
-  id: string,
-  rows: Record<string, unknown>[],
-): Promise<void> {
+export async function saveTable(id: string, rows: Record<string, unknown>[]): Promise<void> {
   const cached = cache.get(id);
   if (!cached) {
     throw new Error(`Table "${id}" is not loaded - call loadTable first`);

.agents/skills/swarm/scripts/types.ts

@@ -56,10 +56,7 @@ export interface CreateSource {
  * the same batch size are grouped together, then chunked into
  * batches of that size.
  */
-export type BatchFn = (
-  row: Record<string, unknown>,
-  rowCount: number,
-) => number;
+export type BatchFn = (row: Record<string, unknown>, rowCount: number) => number;
 
 /**
  * Options for `run()`.

.agents/skills/swarm/scripts/utils.ts

@@ -9,10 +9,7 @@
  * @param path - Dot-separated column path (e.g. `"file"` or `"meta.score"`).
  * @returns The resolved value, or `undefined` if the path is invalid.
  */
-export function readColumn(
-  row: Record<string, unknown>,
-  path: string,
-): unknown {
+export function readColumn(row: Record<string, unknown>, path: string): unknown {
   const segments = path.split(".");
 
   let current = row;