retestkit 1.4.1 → 1.5.0

package/src/prompts/loader.test.ts

@@ -1,100 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { writeFileSync, mkdirSync, rmSync } from "node:fs";
-import { resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import { loadTemplate, interpolate, renderTemplate, clearTemplateCache } from "./loader.js";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-describe("Template Loader", () => {
-  describe("interpolate", () => {
-    it("replaces single variable", () => {
-      const result = interpolate("Hello ${name}!", { name: "World" });
-      expect(result).toBe("Hello World!");
-    });
-
-    it("replaces multiple variables", () => {
-      const result = interpolate("${greeting} ${name}!", { greeting: "Hello", name: "World" });
-      expect(result).toBe("Hello World!");
-    });
-
-    it("replaces same variable multiple times", () => {
-      const result = interpolate("${x} + ${x} = ${y}", { x: "1", y: "2" });
-      expect(result).toBe("1 + 1 = 2");
-    });
-
-    it("keeps unmatched placeholders unchanged", () => {
-      const result = interpolate("Hello ${name}! Your id is ${id}.", { name: "World" });
-      expect(result).toBe("Hello World! Your id is ${id}.");
-    });
-
-    it("handles empty vars object", () => {
-      const result = interpolate("Hello ${name}!", {});
-      expect(result).toBe("Hello ${name}!");
-    });
-
-    it("converts numbers to strings", () => {
-      const result = interpolate("Count: ${count}", { count: 42 });
-      expect(result).toBe("Count: 42");
-    });
-
-    it("converts booleans to strings", () => {
-      const result = interpolate("Active: ${active}", { active: true });
-      expect(result).toBe("Active: true");
-    });
-
-    it("handles undefined values by keeping placeholder", () => {
-      const result = interpolate("Value: ${val}", { val: undefined });
-      expect(result).toBe("Value: ${val}");
-    });
-
-    it("preserves text without placeholders", () => {
-      const result = interpolate("No variables here", { name: "ignored" });
-      expect(result).toBe("No variables here");
-    });
-
-    it("handles multiline templates", () => {
-      const template = `Line 1: \${a}
-Line 2: \${b}
-Line 3: \${c}`;
-      const result = interpolate(template, { a: "A", b: "B", c: "C" });
-      expect(result).toBe("Line 1: A\nLine 2: B\nLine 3: C");
-    });
-  });
-
-  describe("loadTemplate", () => {
-    beforeEach(() => {
-      clearTemplateCache();
-    });
-
-    it("loads existing template file", () => {
-      // This test depends on actual template files existing
-      // Will be validated after templates are created
-    });
-
-    it("throws error for non-existent template", () => {
-      expect(() => loadTemplate("sampling", "non-existent-template")).toThrow();
-    });
-
-    it("caches loaded templates", () => {
-      // Cache behavior is internal, but we can verify it doesn't throw on repeated calls
-      // Will be validated after templates are created
-    });
-  });
-
-  describe("renderTemplate", () => {
-    beforeEach(() => {
-      clearTemplateCache();
-    });
-
-    it("loads and interpolates template in one call", () => {
-      // Will be validated after templates are created
-    });
-  });
-
-  describe("clearTemplateCache", () => {
-    it("clears the cache without error", () => {
-      expect(() => clearTemplateCache()).not.toThrow();
-    });
-  });
-});

package/src/prompts/loader.ts

@@ -1,59 +0,0 @@
-import { readFileSync } from "node:fs";
-import { resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-const templateCache = new Map<string, string>();
-
-/**
- * Load a template file from the templates directory.
- * Templates are cached after first load.
- */
-export function loadTemplate(category: "sampling" | "mcp", name: string): string {
-  const cacheKey = `${category}/${name}`;
-
-  if (templateCache.has(cacheKey)) {
-    return templateCache.get(cacheKey)!;
-  }
-
-  const templatePath = resolve(__dirname, "templates", category, `${name}.md`);
-  const content = readFileSync(templatePath, "utf-8");
-  templateCache.set(cacheKey, content);
-
-  return content;
-}
-
-/**
- * Interpolate variables in a template string.
- * Replaces ${varName} patterns with values from the vars object.
- * Unmatched placeholders are left unchanged.
- */
-export function interpolate(template: string, vars: Record<string, string | number | boolean | undefined>): string {
-  return template.replace(/\$\{(\w+)\}/g, (match, varName) => {
-    const value = vars[varName];
-    if (value === undefined) {
-      return match; // Keep placeholder if var not provided
-    }
-    return String(value);
-  });
-}
-
-/**
- * Load a template and interpolate variables in one step.
- */
-export function renderTemplate(
-  category: "sampling" | "mcp",
-  name: string,
-  vars: Record<string, string | number | boolean | undefined> = {}
-): string {
-  const template = loadTemplate(category, name);
-  return interpolate(template, vars);
-}
-
-/**
- * Clear the template cache (useful for testing).
- */
-export function clearTemplateCache(): void {
-  templateCache.clear();
-}

package/src/prompts/templates/mcp/webtest-crawl.md

@@ -1,7 +0,0 @@
-Please crawl the web application with these parameters:
-
-Analysis ID: ${analysisId}
-Goal: ${goal}
-Strategy: ${strategy}
-
-Use webtest_crawl_app to explore the application. Report progress and let me know if you encounter any obstacles (cookie banners, modals, authentication).

package/src/prompts/templates/mcp/webtest-full-workflow.md

@@ -1,12 +0,0 @@
-Please run a complete web testing workflow for: ${url}
-Focus: ${focus}
-
-Execute these steps in order:
-1. webtest_init - Initialize the workspace
-2. webtest_crawl_app - Explore the application with a goal related to "${focus}"
-3. webtest_discover_features - Identify application features
-4. webtest_discover_flows - Discover flows for each feature
-5. webtest_generate_tests - Create test cases
-6. webtest_run_test - Run at least one critical test
-
-Report progress at each step and summarize the overall testing results at the end.

package/src/resources/index.ts

@@ -1,250 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { join, extname } from "node:path";
-import type { Logger } from "../logger.js";
-import type { Config } from "../schemas/config.js";
-import type { ClientCapabilities } from "../types/capabilities.js";
-import type { WorkspaceManager } from "../workspace/index.js";
-import { createResourceSubscriptions, type ResourceSubscriptions } from "./subscriptions.js";
-
-export { createResourceSubscriptions, type ResourceSubscriptions };
-
-export interface Resource {
-  uri: string;
-  name: string;
-  description?: string;
-  mimeType?: string;
-}
-
-export interface ResourceContent {
-  uri: string;
-  mimeType: string;
-  text?: string;
-  blob?: string;
-}
-
-export interface ResourceManager {
-  listResources(analysisId?: string): Promise<Resource[]>;
-  readResource(uri: string): Promise<ResourceContent>;
-  notifyListChanged(): Promise<void>;
-  notifyResourceUpdated(uri: string): Promise<void>;
-  subscriptions: ResourceSubscriptions;
-}
-
-const MIME_TYPES: Record<string, string> = {
-  ".json": "application/json",
-  ".md": "text/markdown",
-  ".html": "text/html",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-};
-
-export function createResourceManager(
-  config: Config,
-  workspaceManager: WorkspaceManager,
-  sendNotification: (method: string, params: unknown) => Promise<void>,
-  capabilities: ClientCapabilities,
-  logger: Logger
-): ResourceManager {
-  const subscriptions = createResourceSubscriptions(logger);
-  const hasListChanged = capabilities.resourcesListChanged;
-  const hasSubscribe = capabilities.resourcesSubscribe;
-
-  function parseWebtestUri(uri: string): { analysisId: string; path: string } | null {
-    if (!uri.startsWith("webtest://")) {
-      return null;
-    }
-
-    const withoutScheme = uri.slice("webtest://".length);
-    const slashIndex = withoutScheme.indexOf("/");
-
-    if (slashIndex === -1) {
-      return { analysisId: withoutScheme, path: "" };
-    }
-
-    return {
-      analysisId: withoutScheme.slice(0, slashIndex),
-      path: withoutScheme.slice(slashIndex + 1),
-    };
-  }
-
-  function getMimeType(path: string): string {
-    const ext = extname(path).toLowerCase();
-    return MIME_TYPES[ext] || "application/octet-stream";
-  }
-
-  return {
-    subscriptions,
-
-    async listResources(analysisId?: string): Promise<Resource[]> {
-      const resources: Resource[] = [];
-
-      const workspaces = analysisId
-        ? [analysisId]
-        : await workspaceManager.listWorkspaces();
-
-      for (const wsId of workspaces) {
-        if (!(await workspaceManager.workspaceExists(wsId))) {
-          continue;
-        }
-
-        const index = await workspaceManager.readWorkspaceIndex(wsId);
-
-        // Add workspace index (now markdown)
-        resources.push({
-          uri: `webtest://${wsId}/index.md`,
-          name: `Analysis: ${index.url}`,
-          description: `Analysis workspace for ${index.domain}`,
-          mimeType: "text/markdown",
-        });
-
-        // Add crawl resources
-        for (const crawl of index.crawls) {
-          resources.push({
-            uri: `webtest://${wsId}/crawls/${crawl.crawlId}/index.md`,
-            name: `Crawl: ${crawl.goal.slice(0, 50)}`,
-            description: `Crawl ${crawl.status} - ${crawl.pagesVisited} pages`,
-            mimeType: "text/markdown",
-          });
-
-          // Read crawl index to get page resources
-          try {
-            const crawlIndex = await workspaceManager.readCrawlIndex(
-              wsId,
-              crawl.crawlId
-            );
-
-            for (const page of crawlIndex.pages) {
-              resources.push({
-                uri: page.screenshotUri,
-                name: `Screenshot: ${page.title || page.url}`,
-                mimeType: "image/png",
-              });
-              resources.push({
-                uri: page.snapshotUri,
-                name: `Snapshot: ${page.title || page.url}`,
-                mimeType: "text/markdown",
-              });
-            }
-          } catch {
-            // Crawl index might not exist yet
-          }
-        }
-
-        // Add features resources (new structure)
-        if (index.features) {
-          resources.push({
-            uri: index.features.featuresUri,
-            name: `Features (${index.features.featureCount})`,
-            description: "Discovered application features",
-            mimeType: "text/markdown",
-          });
-        }
-
-        // Add feature flows resources
-        if (index.featureFlows) {
-          for (const flow of index.featureFlows) {
-            resources.push({
-              uri: flow.flowsUri,
-              name: `Flows: ${flow.featureSlug}`,
-              description: `${flow.flowCount} flows for ${flow.featureSlug} feature`,
-              mimeType: "text/markdown",
-            });
-          }
-        }
-
-
-        // Add test resources
-        if (index.tests) {
-          resources.push({
-            uri: index.tests.testsUri,
-            name: `Tests (${index.tests.testCount} cases)`,
-            description: "Generated test cases",
-            mimeType: "text/markdown",
-          });
-        }
-
-        // Add test run resources
-        for (const run of index.runs) {
-          resources.push({
-            uri: `webtest://${wsId}/runs/${run.runId}/report.md`,
-            name: `Test Run: ${run.testCaseId}`,
-            description: `Test run ${run.status}`,
-            mimeType: "text/markdown",
-          });
-        }
-      }
-
-      return resources;
-    },
-
-    async readResource(uri: string): Promise<ResourceContent> {
-      const parsed = parseWebtestUri(uri);
-
-      if (!parsed) {
-        throw new Error(`Invalid resource URI: ${uri}`);
-      }
-
-      const { analysisId, path } = parsed;
-      const workspacePath = workspaceManager.getWorkspacePath(analysisId);
-      const filePath = join(workspacePath, path);
-      const mimeType = getMimeType(path);
-
-      try {
-        if (mimeType.startsWith("image/")) {
-          const data = await readFile(filePath);
-          return {
-            uri,
-            mimeType,
-            blob: data.toString("base64"),
-          };
-        } else {
-          const text = await readFile(filePath, "utf-8");
-          return {
-            uri,
-            mimeType,
-            text,
-          };
-        }
-      } catch (error) {
-        throw new Error(
-          `Resource not found: ${uri} (${error instanceof Error ? error.message : "Unknown error"})`
-        );
-      }
-    },
-
-    async notifyListChanged(): Promise<void> {
-      if (!hasListChanged) {
-        logger.debug("listChanged notification skipped (not supported)");
-        return;
-      }
-
-      logger.debug("Emitting resources/list_changed notification");
-
-      try {
-        await sendNotification("notifications/resources/list_changed", {});
-      } catch (error) {
-        logger.warn("Failed to emit list_changed notification", {
-          error: error instanceof Error ? error.message : "Unknown error",
-        });
-      }
-    },
-
-    async notifyResourceUpdated(uri: string): Promise<void> {
-      if (!hasSubscribe || !subscriptions.isSubscribed(uri)) {
-        return;
-      }
-
-      logger.debug("Emitting resources/updated notification", { uri });
-
-      try {
-        await sendNotification("notifications/resources/updated", { uri });
-      } catch (error) {
-        logger.warn("Failed to emit resource updated notification", {
-          uri,
-          error: error instanceof Error ? error.message : "Unknown error",
-        });
-      }
-    },
-  };
-}

package/src/resources/subscriptions.ts

@@ -1,37 +0,0 @@
-import type { Logger } from "../logger.js";
-
-export interface ResourceSubscriptions {
-  subscribe(uri: string): void;
-  unsubscribe(uri: string): void;
-  isSubscribed(uri: string): boolean;
-  getSubscribers(): string[];
-  clear(): void;
-}
-
-export function createResourceSubscriptions(logger: Logger): ResourceSubscriptions {
-  const subscriptions = new Set<string>();
-
-  return {
-    subscribe(uri: string): void {
-      subscriptions.add(uri);
-      logger.debug("Resource subscribed", { uri });
-    },
-
-    unsubscribe(uri: string): void {
-      subscriptions.delete(uri);
-      logger.debug("Resource unsubscribed", { uri });
-    },
-
-    isSubscribed(uri: string): boolean {
-      return subscriptions.has(uri);
-    },
-
-    getSubscribers(): string[] {
-      return Array.from(subscriptions);
-    },
-
-    clear(): void {
-      subscriptions.clear();
-    },
-  };
-}