veryfront 0.1.208 → 0.1.210

package/src/cli/mcp/tools/run-tests-tool.ts

@@ -0,0 +1,101 @@
+/**
+ * MCP tool: vf_run_tests
+ *
+ * Runs the project test suite via subprocess and returns structured results.
+ * Reuses parseTestOutput from the CLI test command.
+ */
+import * as dntShim from "../../../_dnt.shims.js";
+
+
+import { z } from "zod";
+import type { MCPTool } from "../../../src/mcp/index.js";
+import { parseTestOutput, type TestResult } from "../../commands/test/command.js";
+
+const runTestsInput = z.object({
+  filter: z.string().optional().describe(
+    "Filter tests by name pattern. Example: 'router' to run only tests matching 'router'.",
+  ),
+  parallel: z.boolean().optional().default(false).describe(
+    "Run tests in parallel. Defaults to false.",
+  ),
+  timeout: z.number().optional().default(300000).describe(
+    "Maximum time to wait for test completion in milliseconds. Defaults to 300000 (5 minutes).",
+  ),
+});
+
+type RunTestsInput = z.infer<typeof runTestsInput>;
+
+/** Build the deno test command args from input options. */
+export function buildTestArgs(input: { filter?: string; parallel?: boolean }): string[] {
+  return [
+    "test",
+    "--no-check",
+    "--allow-all",
+    "--unstable-worker-options",
+    "--unstable-net",
+    ...(input.parallel ? ["--parallel"] : []),
+    ...(input.filter ? [`--filter=${input.filter}`] : []),
+  ];
+}
+
+/** Env vars required for deterministic test runs. */
+export const TEST_ENV: Record<string, string> = {
+  VF_DISABLE_LRU_INTERVAL: "1",
+  SSR_TRANSFORM_PER_PROJECT_LIMIT: "0",
+  REVALIDATION_PER_PROJECT_LIMIT: "0",
+  NODE_ENV: "production",
+  LOG_FORMAT: "text",
+};
+
+/** Spawn deno test and return structured results. Exported for standalone reuse. */
+export async function executeTests(
+  input: { filter?: string; parallel?: boolean; timeout?: number },
+): Promise<TestResult> {
+  const cmd = new dntShim.Deno.Command("deno", {
+    args: buildTestArgs(input),
+    stdout: "piped",
+    stderr: "piped",
+    env: TEST_ENV,
+  });
+
+  const child = cmd.spawn();
+  const timeoutMs = input.timeout ?? 300000;
+
+  const result = await Promise.race([
+    child.output(),
+    new Promise<never>((_, reject) => {
+      const timer = dntShim.setTimeout(() => {
+        try {
+          child.kill();
+        } catch {
+          // Process may have already exited
+        }
+        reject(new Error(`Test execution timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      // Don't prevent process exit while waiting
+      dntShim.Deno.unrefTimer(timer);
+    }),
+  ]);
+
+  const stdout = new TextDecoder().decode(result.stdout);
+  const stderr = new TextDecoder().decode(result.stderr);
+  return parseTestOutput(stdout + "\n" + stderr, result.code);
+}
+
+export const vfRunTests: MCPTool<RunTestsInput, TestResult> = {
+  name: "vf_run_tests",
+  title: "Run Tests",
+  annotations: {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+  },
+  description:
+    "Use this when you need to run the project's test suite and get structured pass/fail results. " +
+    "Returns a summary with total, passed, failed, skipped counts and failure details including " +
+    "file path, test name, error message, and line number. " +
+    "Do not use for lint checks — use vf_run_lint instead.",
+  inputSchema: runTestsInput,
+  execute: (input) => executeTests(input),
+};

package/src/deno.js

@@ -1,6 +1,6 @@
 export default {
   "name": "veryfront",
-  "version": "0.1.208",
+  "version": "0.1.210",
   "license": "Apache-2.0",
   "nodeModulesDir": "auto",
   "exclude": [

package/src/src/agent/data-stream.ts

@@ -37,6 +37,29 @@ export function mergeToolInputDelta(currentArguments: string, nextDelta: string)
     }
   }
 
+  if (nextDelta.length === 0) {
+    return currentArguments;
+  }
+
+  if (currentArguments.length === 0) {
+    return nextDelta;
+  }
+
+  if (nextDelta === currentArguments || currentArguments.includes(nextDelta)) {
+    return currentArguments;
+  }
+
+  if (nextDelta.startsWith(currentArguments)) {
+    return nextDelta;
+  }
+
+  const maxOverlap = Math.min(currentArguments.length, nextDelta.length);
+  for (let overlap = maxOverlap; overlap > 0; overlap--) {
+    if (currentArguments.endsWith(nextDelta.slice(0, overlap))) {
+      return currentArguments + nextDelta.slice(overlap);
+    }
+  }
+
   return currentArguments + nextDelta;
 }