@rubytech/create-maxy-code 0.1.114 → 0.1.115

package/payload/premium-plugins/real-agent/plugins/property-data/mcp/package.json

@@ -1,21 +0,0 @@
-{
-  "name": "@maxy/property-data",
-  "version": "0.1.0",
-  "private": true,
-  "type": "module",
-  "main": "dist/index.js",
-  "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "test": "vitest run"
-  },
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.1",
-    "neo4j-driver": "^5.28.1"
-  },
-  "devDependencies": {
-    "typescript": "^5.7.0",
-    "@types/node": "^22.0.0",
-    "vitest": "^4.1.2"
-  }
-}

package/payload/premium-plugins/real-agent/plugins/property-data/mcp/src/__tests__/endpoints.test.ts

@@ -1,252 +0,0 @@
-/**
- * Task 144 — per-endpoint coverage for the 10 new PropertyData adapters.
- * For each new endpoint, assert:
- *   1. happy path — JSON parses and round-trips through the adapter
- *   2. 4xx upstream → PropertyDataError with status preserved
- *   3. non-JSON body → BadResponseError
- *   4. missing key → KeyNotRegisteredError
- *
- * The existing propertydata-api.test.ts proves the four paths fire from
- * `propertyDataCall`; this file proves each of the 10 adapter exports
- * threads its own endpoint path through that same plumbing so the
- * MCP tool actually hits the right URL.
- */
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-// Mock the Neo4j layer keyed by accountId so each test can choose an
-// already-registered account (happy / 4xx / bad-response) or a brand-new
-// "ghost" account (missing-key) without ordering coupling.
-vi.mock("../lib/neo4j.js", () => {
-  const stored = new Map<string, string>();
-  return {
-    getSession: () => ({
-      run: vi.fn(async (cypher: string, params: Record<string, unknown>) => {
-        const accountId = String(params.accountId ?? "");
-        if (/MATCH \(k:PropertyDataKey/.test(cypher) && /RETURN/.test(cypher)) {
-          const encryptedKey = stored.get(accountId);
-          return {
-            records: encryptedKey
-              ? [
-                  {
-                    get: (k: string) => {
-                      if (k === "encryptedKey") return encryptedKey;
-                      if (k === "createdAt") return "2026-01-01T00:00:00Z";
-                      if (k === "updatedAt") return "2026-01-01T00:00:00Z";
-                      return null;
-                    },
-                  },
-                ]
-              : [],
-          };
-        }
-        if (/MERGE \(k:PropertyDataKey/.test(cypher)) {
-          stored.set(accountId, String(params.encryptedKey));
-          return { records: [] };
-        }
-        if (/DELETE k/.test(cypher)) {
-          const had = stored.delete(accountId);
-          return {
-            records: [
-              {
-                get: (k: string) =>
-                  k === "deleted" ? { toNumber: () => (had ? 1 : 0) } : null,
-              },
-            ],
-          };
-        }
-        return { records: [] };
-      }),
-      close: vi.fn(async () => {}),
-    }),
-    closeDriver: vi.fn(async () => {}),
-  };
-});
-
-vi.mock("../lib/crypto.js", () => ({
-  encrypt: (s: string) => `enc:${s}`,
-  decrypt: (s: string) => s.replace(/^enc:/, ""),
-}));
-
-import {
-  pricesPerSqf,
-  soldPricesPerSqf,
-  crime,
-  floodRisk,
-  councilTax,
-  planningApplications,
-  addressMatchUprn,
-  growthPsf,
-  demandRent,
-  propertyTypes,
-} from "../tools/endpoints.js";
-import {
-  KeyNotRegisteredError,
-  PropertyDataError,
-  BadResponseError,
-} from "../lib/propertydata-api.js";
-import { keyRegister } from "../tools/key-register.js";
-
-const originalFetch = globalThis.fetch;
-
-function mockFetch(impl: (url: string) => Response | Promise<Response>) {
-  const fn = vi.fn(async (url: string | URL | Request) => impl(String(url))) as unknown as typeof fetch;
-  globalThis.fetch = fn;
-  return fn as unknown as ReturnType<typeof vi.fn>;
-}
-
-async function registerTestKey(accountId: string) {
-  mockFetch(() => new Response(JSON.stringify({ status: "success", uk_hpi: 100 }), { status: 200 }));
-  await keyRegister({ apiKey: "test-key-12345", accountId });
-}
-
-beforeEach(() => {
-  // no-op
-});
-
-afterEach(() => {
-  globalThis.fetch = originalFetch;
-  vi.restoreAllMocks();
-});
-
-interface EndpointCase {
-  toolName: string;
-  endpointPath: string;
-  adapter: (args: { accountId: string } & Record<string, unknown>) => Promise<string>;
-  sampleParams: Record<string, unknown>;
-  happyPayload: Record<string, unknown>;
-  happyAssertField: string;
-}
-
-const cases: EndpointCase[] = [
-  {
-    toolName: "property-data-prices-per-sqf",
-    endpointPath: "prices-per-sqf",
-    adapter: pricesPerSqf,
-    sampleParams: { postcode: "CM23 2UJ" },
-    happyPayload: { status: "success", data: { avg: 450 } },
-    happyAssertField: "avg",
-  },
-  {
-    toolName: "property-data-sold-prices-per-sqf",
-    endpointPath: "sold-prices-per-sqf",
-    adapter: soldPricesPerSqf,
-    sampleParams: { postcode: "CM23 2UJ", max_age: 24 },
-    happyPayload: { status: "success", data: { avg: 425, sales: [] } },
-    happyAssertField: "avg",
-  },
-  {
-    toolName: "property-data-crime",
-    endpointPath: "crime",
-    adapter: crime,
-    sampleParams: { postcode: "CM23" },
-    happyPayload: { status: "success", data: { rate_per_1000: 42 } },
-    happyAssertField: "rate_per_1000",
-  },
-  {
-    toolName: "property-data-flood-risk",
-    endpointPath: "flood-risk",
-    adapter: floodRisk,
-    sampleParams: { postcode: "CM23 2UJ" },
-    happyPayload: { status: "success", data: { river: "very-low" } },
-    happyAssertField: "river",
-  },
-  {
-    toolName: "property-data-council-tax",
-    endpointPath: "council-tax",
-    adapter: councilTax,
-    sampleParams: { postcode: "CM23 2UJ" },
-    happyPayload: { status: "success", data: { council: "East Herts", band_d: 2100 } },
-    happyAssertField: "council",
-  },
-  {
-    toolName: "property-data-planning-applications",
-    endpointPath: "planning-applications",
-    adapter: planningApplications,
-    sampleParams: { postcode: "CM23", results: 10 },
-    happyPayload: { status: "success", data: { applications: [] } },
-    happyAssertField: "applications",
-  },
-  {
-    toolName: "property-data-address-match-uprn",
-    endpointPath: "address-match-uprn",
-    adapter: addressMatchUprn,
-    sampleParams: { address: "1 The High Street, Bishop's Stortford, CM23 2UJ" },
-    happyPayload: { status: "success", data: { uprn: "10001234567" } },
-    happyAssertField: "uprn",
-  },
-  {
-    toolName: "property-data-growth-psf",
-    endpointPath: "growth-psf",
-    adapter: growthPsf,
-    sampleParams: { postcode: "CM23" },
-    happyPayload: { status: "success", data: { series: [{ year: 2019, psf: 400 }] } },
-    happyAssertField: "series",
-  },
-  {
-    toolName: "property-data-demand-rent",
-    endpointPath: "demand-rent",
-    adapter: demandRent,
-    sampleParams: { postcode: "CM23", bedrooms: 3 },
-    happyPayload: { status: "success", data: { for_rent: 12, lets_per_month: 4 } },
-    happyAssertField: "for_rent",
-  },
-  {
-    toolName: "property-data-property-types",
-    endpointPath: "property-types",
-    adapter: propertyTypes,
-    sampleParams: { postcode: "CM23" },
-    happyPayload: { status: "success", data: { detached: 28, flat: 12 } },
-    happyAssertField: "detached",
-  },
-];
-
-describe("Task 144 endpoint adapters", () => {
-  for (const c of cases) {
-    describe(c.toolName, () => {
-      const acct = `acct-${c.endpointPath}`;
-
-      it("happy path returns the parsed JSON payload", async () => {
-        await registerTestKey(acct);
-        let capturedUrl = "";
-        mockFetch((url) => {
-          capturedUrl = url;
-          return new Response(JSON.stringify(c.happyPayload), { status: 200 });
-        });
-        const text = await c.adapter({ accountId: acct, ...c.sampleParams });
-        expect(capturedUrl).toContain(`/${c.endpointPath}?`);
-        const parsed = JSON.parse(text);
-        // payload has shape { status, data: { ... } } — assert the field
-        // exists somewhere in the round-tripped output.
-        expect(JSON.stringify(parsed)).toContain(c.happyAssertField);
-      });
-
-      it("maps HTTP 4xx to PropertyDataError preserving the status", async () => {
-        await registerTestKey(acct);
-        mockFetch(() => new Response("bad request", { status: 400 }));
-        try {
-          await c.adapter({ accountId: acct, ...c.sampleParams });
-          throw new Error("expected PropertyDataError");
-        } catch (err) {
-          expect(err).toBeInstanceOf(PropertyDataError);
-          expect((err as PropertyDataError).status).toBe(400);
-        }
-      });
-
-      it("maps non-JSON body to BadResponseError", async () => {
-        await registerTestKey(acct);
-        mockFetch(() => new Response("<html>maintenance</html>", { status: 200 }));
-        await expect(
-          c.adapter({ accountId: acct, ...c.sampleParams }),
-        ).rejects.toBeInstanceOf(BadResponseError);
-      });
-
-      it("throws KeyNotRegisteredError when no key is stored", async () => {
-        // brand-new account with nothing registered
-        await expect(
-          c.adapter({ accountId: `${acct}-ghost`, ...c.sampleParams }),
-        ).rejects.toBeInstanceOf(KeyNotRegisteredError);
-      });
-    });
-  }
-});

package/payload/premium-plugins/real-agent/plugins/property-data/mcp/src/__tests__/key-roundtrip.test.ts

@@ -1,107 +0,0 @@
-/**
- * Key register / list / deregister round-trip against a mocked Neo4j
- * session + mocked crypto + mocked fetch (for key validation against
- * PropertyData's /national-hpi endpoint).
- */
-
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-vi.mock("../lib/neo4j.js", () => {
-  let stored: { encryptedKey: string; createdAt: string; updatedAt: string } | null = null;
-  return {
-    getSession: () => ({
-      run: vi.fn(async (cypher: string, params: Record<string, unknown>) => {
-        if (/CREATE INDEX/.test(cypher)) return { records: [] };
-        if (/MERGE \(k:PropertyDataKey/.test(cypher)) {
-          const now = String(params.now ?? new Date().toISOString());
-          stored = {
-            encryptedKey: String(params.encryptedKey),
-            createdAt: stored?.createdAt ?? now,
-            updatedAt: now,
-          };
-          return { records: [] };
-        }
-        if (/MATCH \(k:PropertyDataKey/.test(cypher) && /DELETE/.test(cypher)) {
-          const count = stored ? 1 : 0;
-          stored = null;
-          return {
-            records: [{ get: (k: string) => (k === "deleted" ? { toNumber: () => count } : null) }],
-          };
-        }
-        if (/MATCH \(k:PropertyDataKey/.test(cypher) && /RETURN/.test(cypher)) {
-          return {
-            records: stored
-              ? [
-                  {
-                    get: (k: string) => {
-                      if (k === "encryptedKey") return stored!.encryptedKey;
-                      if (k === "createdAt") return stored!.createdAt;
-                      if (k === "updatedAt") return stored!.updatedAt;
-                      return null;
-                    },
-                  },
-                ]
-              : [],
-          };
-        }
-        return { records: [] };
-      }),
-      close: vi.fn(async () => {}),
-    }),
-    closeDriver: vi.fn(async () => {}),
-  };
-});
-
-vi.mock("../lib/crypto.js", () => ({
-  encrypt: (s: string) => `enc:${s}`,
-  decrypt: (s: string) => s.replace(/^enc:/, ""),
-}));
-
-import { keyRegister } from "../tools/key-register.js";
-import { keyDeregister } from "../tools/key-deregister.js";
-import { keyList } from "../tools/key-list.js";
-
-const originalFetch = globalThis.fetch;
-
-afterEach(() => {
-  globalThis.fetch = originalFetch;
-  vi.restoreAllMocks();
-});
-
-describe("key round-trip", () => {
-  it("rejects an unregistered account on list", async () => {
-    const out = await keyList({ accountId: "acc-empty" });
-    expect(out).toMatch(/No PropertyData API key registered/);
-  });
-
-  it("rejects deregister when no key is stored", async () => {
-    await expect(keyDeregister({ accountId: "acc-empty-2" })).rejects.toThrow(
-      /No PropertyData API key/,
-    );
-  });
-
-  it("rejects registration when PropertyData returns 401", async () => {
-    globalThis.fetch = vi.fn(
-      async () => new Response("unauthorized", { status: 401 }),
-    ) as unknown as typeof fetch;
-    await expect(keyRegister({ apiKey: "bad-key", accountId: "acc-x" })).rejects.toThrow(
-      /rejected the API key/,
-    );
-  });
-
-  it("registers, lists, then deregisters successfully", async () => {
-    globalThis.fetch = vi.fn(
-      async () =>
-        new Response(JSON.stringify({ status: "success", uk_hpi: 100 }), { status: 200 }),
-    ) as unknown as typeof fetch;
-    await keyRegister({ apiKey: "good-key-12345", accountId: "acc-r" });
-
-    const listed = await keyList({ accountId: "acc-r" });
-    expect(listed).toMatch(/PropertyData API key registered/);
-    expect(listed).not.toContain("good-key-12345");
-
-    await keyDeregister({ accountId: "acc-r" });
-    const afterDelete = await keyList({ accountId: "acc-r" });
-    expect(afterDelete).toMatch(/No PropertyData API key/);
-  });
-});

package/payload/premium-plugins/real-agent/plugins/property-data/mcp/src/__tests__/propertydata-api.test.ts

@@ -1,184 +0,0 @@
-/**
- * propertydata-api.ts behaviour with mocked fetch + mocked neo4j store.
- * Covers:
- *  - missing-key path throws KeyNotRegisteredError
- *  - 4xx upstream maps to PropertyDataError with the status preserved
- *  - 5xx upstream maps to PropertyDataError with the status preserved
- *  - PropertyData JSON envelope with status=error maps to PropertyDataError
- *  - non-JSON body maps to BadResponseError
- *  - successful call returns the payload as a JSON string
- */
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-vi.mock("../lib/neo4j.js", () => {
-  let stored: { encryptedKey: string } | null = null;
-  return {
-    getSession: () => ({
-      run: vi.fn(async (cypher: string, params: Record<string, unknown>) => {
-        if (/MATCH \(k:PropertyDataKey/.test(cypher) && /RETURN/.test(cypher)) {
-          return {
-            records: stored
-              ? [
-                  {
-                    get: (k: string) => {
-                      if (k === "encryptedKey") return stored!.encryptedKey;
-                      if (k === "createdAt") return "2026-01-01T00:00:00Z";
-                      if (k === "updatedAt") return "2026-01-01T00:00:00Z";
-                      return null;
-                    },
-                  },
-                ]
-              : [],
-          };
-        }
-        if (/MERGE \(k:PropertyDataKey/.test(cypher)) {
-          stored = { encryptedKey: String(params.encryptedKey) };
-          return { records: [] };
-        }
-        if (/DELETE k/.test(cypher)) {
-          const count = stored ? 1 : 0;
-          stored = null;
-          return {
-            records: [{ get: (k: string) => (k === "deleted" ? { toNumber: () => count } : null) }],
-          };
-        }
-        return { records: [] };
-      }),
-      close: vi.fn(async () => {}),
-    }),
-    closeDriver: vi.fn(async () => {}),
-  };
-});
-
-vi.mock("../lib/crypto.js", () => ({
-  encrypt: (s: string) => `enc:${s}`,
-  decrypt: (s: string) => s.replace(/^enc:/, ""),
-}));
-
-import {
-  propertyDataCall,
-  KeyNotRegisteredError,
-  PropertyDataError,
-  BadResponseError,
-} from "../lib/propertydata-api.js";
-import { keyRegister } from "../tools/key-register.js";
-
-const originalFetch = globalThis.fetch;
-
-function mockFetch(impl: (url: string) => Response | Promise<Response>) {
-  globalThis.fetch = vi.fn(async (url: string | URL | Request) =>
-    impl(String(url)),
-  ) as unknown as typeof fetch;
-}
-
-beforeEach(() => {
-  // no-op
-});
-
-afterEach(() => {
-  globalThis.fetch = originalFetch;
-  vi.restoreAllMocks();
-});
-
-async function registerTestKey() {
-  mockFetch(() => new Response(JSON.stringify({ status: "success", uk_hpi: 100 }), { status: 200 }));
-  await keyRegister({ apiKey: "test-key-12345", accountId: "acc-1" });
-}
-
-describe("propertyDataCall", () => {
-  it("throws KeyNotRegisteredError when no key is stored", async () => {
-    await expect(
-      propertyDataCall({
-        endpoint: "demand",
-        toolName: "property-data-demand",
-        accountId: "ghost-account",
-        params: { postcode: "SN7" },
-      }),
-    ).rejects.toBeInstanceOf(KeyNotRegisteredError);
-  });
-
-  it("returns the JSON payload as a string on success", async () => {
-    await registerTestKey();
-    mockFetch(
-      () => new Response(JSON.stringify({ status: "success", point_estimate: 350000 }), { status: 200 }),
-    );
-    const result = await propertyDataCall({
-      endpoint: "valuation-sale",
-      toolName: "property-data-valuation-sale",
-      accountId: "acc-1",
-      params: { postcode: "SN7", type: "detached", bedrooms: 3 },
-    });
-    expect(result).toContain("point_estimate");
-    expect(JSON.parse(result).point_estimate).toBe(350000);
-  });
-
-  it("maps HTTP 4xx to PropertyDataError preserving the status", async () => {
-    await registerTestKey();
-    mockFetch(() => new Response("bad postcode", { status: 400 }));
-    try {
-      await propertyDataCall({
-        endpoint: "demand",
-        toolName: "property-data-demand",
-        accountId: "acc-1",
-        params: { postcode: "INVALID" },
-      });
-      throw new Error("expected PropertyDataError");
-    } catch (err) {
-      expect(err).toBeInstanceOf(PropertyDataError);
-      expect((err as PropertyDataError).status).toBe(400);
-    }
-  });
-
-  it("maps HTTP 5xx to PropertyDataError preserving the status", async () => {
-    await registerTestKey();
-    mockFetch(() => new Response("upstream down", { status: 503 }));
-    try {
-      await propertyDataCall({
-        endpoint: "demand",
-        toolName: "property-data-demand",
-        accountId: "acc-1",
-        params: { postcode: "SN7" },
-      });
-      throw new Error("expected PropertyDataError");
-    } catch (err) {
-      expect(err).toBeInstanceOf(PropertyDataError);
-      expect((err as PropertyDataError).status).toBe(503);
-    }
-  });
-
-  it("maps PropertyData status=error envelope to PropertyDataError", async () => {
-    await registerTestKey();
-    mockFetch(
-      () =>
-        new Response(JSON.stringify({ status: "error", message: "Insufficient comparables" }), {
-          status: 200,
-        }),
-    );
-    try {
-      await propertyDataCall({
-        endpoint: "valuation-sale",
-        toolName: "property-data-valuation-sale",
-        accountId: "acc-1",
-        params: { postcode: "SN7" },
-      });
-      throw new Error("expected PropertyDataError");
-    } catch (err) {
-      expect(err).toBeInstanceOf(PropertyDataError);
-      expect((err as PropertyDataError).upstreamMessage).toMatch(/Insufficient/);
-    }
-  });
-
-  it("maps non-JSON body to BadResponseError", async () => {
-    await registerTestKey();
-    mockFetch(() => new Response("<html>service maintenance</html>", { status: 200 }));
-    await expect(
-      propertyDataCall({
-        endpoint: "demand",
-        toolName: "property-data-demand",
-        accountId: "acc-1",
-        params: { postcode: "SN7" },
-      }),
-    ).rejects.toBeInstanceOf(BadResponseError);
-  });
-});

package/payload/premium-plugins/real-agent/plugins/property-data/mcp/src/__tests__/schema-parity.test.ts

@@ -1,62 +0,0 @@
-/**
- * Schema parity: every tool declared in PLUGIN.md frontmatter must have a
- * handler registered in index.ts, and every handler in index.ts must be
- * declared in PLUGIN.md. Blocks silent drift between the manifest the
- * platform reads and the tool surface the server exposes.
- */
-
-import { describe, expect, it } from "vitest";
-import { readFileSync } from "node:fs";
-import { resolve, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const here = dirname(fileURLToPath(import.meta.url));
-const PLUGIN_ROOT = resolve(here, "../../..");
-
-function readPluginMdTools(): string[] {
-  const md = readFileSync(resolve(PLUGIN_ROOT, "PLUGIN.md"), "utf-8");
-  const fmMatch = md.match(/^---\n([\s\S]*?)\n---/);
-  if (!fmMatch) throw new Error("PLUGIN.md frontmatter not found");
-  const tools: string[] = [];
-  for (const line of fmMatch[1].split("\n")) {
-    const m = line.match(/^\s+-\s+name:\s+(\S+)/);
-    if (m) tools.push(m[1]);
-  }
-  return tools;
-}
-
-function readIndexTools(): string[] {
-  const src = readFileSync(resolve(PLUGIN_ROOT, "mcp/src/index.ts"), "utf-8");
-  const matches = src.matchAll(/server\.tool\(\s*"([^"]+)"/g);
-  return Array.from(matches, (m) => m[1]);
-}
-
-describe("schema parity", () => {
-  it("PLUGIN.md frontmatter and index.ts register the same tool set", () => {
-    const declared = readPluginMdTools().sort();
-    const registered = readIndexTools().sort();
-    expect(registered).toEqual(declared);
-  });
-
-  it("declares all 22 tools (3 key-mgmt + 19 endpoints)", () => {
-    const declared = readPluginMdTools();
-    expect(declared).toHaveLength(22);
-    expect(declared).toContain("property-data-key-register");
-    expect(declared).toContain("property-data-valuation-sale");
-    expect(declared).toContain("property-data-national-hpi");
-    for (const name of [
-      "property-data-prices-per-sqf",
-      "property-data-sold-prices-per-sqf",
-      "property-data-crime",
-      "property-data-flood-risk",
-      "property-data-council-tax",
-      "property-data-planning-applications",
-      "property-data-address-match-uprn",
-      "property-data-growth-psf",
-      "property-data-demand-rent",
-      "property-data-property-types",
-    ]) {
-      expect(declared).toContain(name);
-    }
-  });
-});