stylegallery 0.1.0

package/scripts/test-agent-mcp.mjs

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+/**
+ * MCP adapter contract harness.
+ *
+ * This is deliberately an in-memory test: it exercises the official stable
+ * MCP SDK's initialize/list/read/call path without making stdio, network, or
+ * filesystem state part of the proof.  The StyleGallery adapter remains the
+ * only domain implementation under test.
+ */
+
+function parseTextContent(response) {
+  const text = response?.content?.find((item) => item?.type === "text")?.text;
+  if (typeof text !== "string") return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+function responseEnvelope(response) {
+  if (response?.structuredContent && typeof response.structuredContent === "object") {
+    return response.structuredContent;
+  }
+  return parseTextContent(response);
+}
+
+function result(name, expected, actual, ok) {
+  return { actual, expected, name, ok };
+}
+
+function denialObserved(error, response) {
+  if (error) {
+    const code = error?.code ?? error?.data?.code;
+    const message = String(error?.message ?? error);
+    return {
+      code,
+      message,
+      observed: ["-32601", "-32602", "method_not_found", "operation_not_exposed", "read_only_denied"]
+        .some((item) => String(code) === item || message.toLowerCase().includes(item.replaceAll("_", " ")))
+        || /unknown|not found|not exposed|read.?only|proposal/i.test(message),
+    };
+  }
+  const envelope = responseEnvelope(response);
+  const codes = Array.isArray(envelope?.failures)
+    ? envelope.failures.map((item) => item?.code).filter((item) => typeof item === "string")
+    : [];
+  const message = typeof envelope === "string"
+    ? envelope
+    : String(response?.content?.find((item) => item?.type === "text")?.text ?? "");
+  const protocolCode = message.match(/-326\d+/)?.[0] ?? null;
+  const codeDenied = codes.some((code) => /denied|not.?exposed|not.?found|read.?only|unknown/i.test(code));
+  const messageDenied = /unknown|not found|not exposed|read.?only|proposal|(-32601)|(-32602)/i.test(message);
+  return {
+    code: codes[0] ?? protocolCode,
+    message,
+    isError: response?.isError === true,
+    observed: response?.isError === true && (codeDenied || messageDenied),
+  };
+}
+
+async function importDependencies(results) {
+  let sdk;
+  try {
+    sdk = {
+      ...(await import("@modelcontextprotocol/sdk/server/mcp.js")),
+      ...(await import("@modelcontextprotocol/sdk/client/index.js")),
+      ...(await import("@modelcontextprotocol/sdk/inMemory.js")),
+    };
+  } catch (error) {
+    results.push(result(
+      "stable_sdk_available",
+      "official @modelcontextprotocol/sdk v1 can be imported",
+      { code: "mcp_sdk_unavailable", error: error instanceof Error ? error.message : String(error) },
+      false,
+    ));
+    return null;
+  }
+  results.push(result(
+    "stable_sdk_available",
+    "official McpServer, Client, and InMemoryTransport exports are available",
+    { exports: ["McpServer", "Client", "InMemoryTransport"].filter((name) => typeof sdk[name] === "function") },
+    typeof sdk.McpServer === "function" && typeof sdk.Client === "function" && typeof sdk.InMemoryTransport?.createLinkedPair === "function",
+  ));
+  if (typeof sdk.McpServer !== "function" || typeof sdk.Client !== "function" || typeof sdk.InMemoryTransport?.createLinkedPair !== "function") return null;
+  return sdk;
+}
+
+async function importAdapter(results) {
+  try {
+    const adapter = await import("./agent-native/mcp-adapter.mjs");
+    const factory = adapter.createStyleGalleryMcpServer ?? adapter.createMcpServer;
+    results.push(result(
+      "adapter_factory_available",
+      "mcp-adapter exports createStyleGalleryMcpServer",
+      { exports: Object.keys(adapter).sort() },
+      typeof factory === "function",
+    ));
+    return factory;
+  } catch (error) {
+    results.push(result(
+      "adapter_factory_available",
+      "mcp-adapter exports createStyleGalleryMcpServer",
+      { code: "mcp_adapter_unavailable", error: error instanceof Error ? error.message : String(error) },
+      false,
+    ));
+    return null;
+  }
+}
+
+async function main() {
+  const results = [];
+  const sdk = await importDependencies(results);
+  const createServer = await importAdapter(results);
+  if (!sdk || !createServer) {
+    const report = { ok: false, results };
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const server = await createServer();
+  const [clientTransport, serverTransport] = sdk.InMemoryTransport.createLinkedPair();
+  const client = new sdk.Client({ name: "stylegallery-mcp-conformance", version: "1.0.0" });
+  try {
+    await Promise.all([server.connect(serverTransport), client.connect(clientTransport)]);
+    const capabilities = client.getServerCapabilities?.() ?? {};
+    results.push(result(
+      "initialize_capability_negotiation",
+      "initialized client/server expose resources and tools",
+      { capabilities },
+      Boolean(capabilities && typeof capabilities === "object"
+        && capabilities.resources && capabilities.tools),
+    ));
+
+    const listedTools = await client.listTools();
+    const toolNames = (listedTools?.tools ?? []).map((item) => item?.name).filter((item) => typeof item === "string").sort();
+    const expectedTools = ["claims", "context", "discover", "ops", "resolve", "retrieve"];
+    results.push(result(
+      "read_only_tool_allowlist",
+      "exactly the six public read operations are advertised",
+      { toolNames, expectedTools },
+      expectedTools.every((name) => toolNames.includes(name))
+        && toolNames.length === expectedTools.length
+        && !toolNames.some((name) => /proposal|promote|decide|reconcile|write|delete|execute/i.test(name)),
+    ));
+
+    const listedResources = await client.listResources();
+    const resourceUris = (listedResources?.resources ?? []).map((item) => item?.uri).filter((item) => typeof item === "string").sort();
+    const expectedResources = ["sg://manifest", "sg://self"];
+    results.push(result(
+      "read_only_resource_catalog",
+      "sg://self and sg://manifest are advertised as immutable resources",
+      { resourceUris, expectedResources },
+      expectedResources.every((uri) => resourceUris.includes(uri)),
+    ));
+
+    for (const uri of expectedResources) {
+      let response;
+      try {
+        response = await client.readResource({ uri });
+        const contents = response?.contents ?? [];
+        const text = contents.find((item) => item?.uri === uri)?.text;
+        let parsed = null;
+        try { parsed = JSON.parse(text); } catch { /* structured resource text is checked below */ }
+        results.push(result(
+          `read_resource_${uri.slice("sg://".length)}`,
+          "one JSON resource content with the requested immutable URI",
+          { contents: contents.length, parsedType: parsed === null ? typeof text : typeof parsed, response },
+          contents.length > 0 && typeof text === "string" && text.length > 0 && parsed !== null && typeof parsed === "object",
+        ));
+      } catch (error) {
+        results.push(result(
+          `read_resource_${uri.slice("sg://".length)}`,
+          "resource/read succeeds over the official SDK",
+          { code: "resource_read_failed", error: error instanceof Error ? error.message : String(error) },
+          false,
+        ));
+      }
+    }
+
+    for (const name of ["discover", "ops"]) {
+      try {
+        const response = await client.callTool({ name, arguments: {} });
+        const envelope = responseEnvelope(response);
+        results.push(result(
+          `call_read_tool_${name}`,
+          "tools/call returns a successful structured domain envelope",
+          { response, envelope },
+          response?.isError !== true && envelope?.ok === true && envelope?.operation === name && envelope?.result && typeof envelope.result === "object",
+        ));
+      } catch (error) {
+        results.push(result(
+          `call_read_tool_${name}`,
+          "tools/call returns a successful structured domain envelope",
+          { code: "tool_call_failed", error: error instanceof Error ? error.message : String(error) },
+          false,
+        ));
+      }
+    }
+
+    let denial;
+    try {
+      const response = await client.callTool({ name: "proposal.create", arguments: {} });
+      denial = denialObserved(null, response);
+    } catch (error) {
+      denial = denialObserved(error, null);
+    }
+    results.push(result(
+      "mutating_tool_denied",
+      "a mutating operation is not exposed and is denied by the read-only MCP surface",
+      denial,
+      denial.observed === true,
+    ));
+  } catch (error) {
+    results.push(result(
+      "sdk_round_trip",
+      "MCP initialize/list/read/call completes without transport failure",
+      { code: "mcp_round_trip_failed", error: error instanceof Error ? error.message : String(error) },
+      false,
+    ));
+  } finally {
+    await client.close().catch(() => {});
+    const closed = server.close?.();
+    if (closed && typeof closed.catch === "function") await closed.catch(() => {});
+  }
+
+  const report = { ok: results.every((item) => item.ok), results };
+  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  process.exitCode = report.ok ? 0 : 1;
+}
+
+await main().catch((error) => {
+  const report = {
+    ok: false,
+    results: [result(
+      "mcp_harness_runtime",
+      "harness emits structured JSON instead of crashing",
+      { code: "mcp_harness_runtime", error: error instanceof Error ? error.message : String(error) },
+      false,
+    )],
+  };
+  process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  process.exitCode = 1;
+});

package/scripts/test-agent-native-schemas.mjs

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import Ajv2020 from "ajv/dist/2020.js";
+import addFormats from "ajv-formats";
+
+import { agentNativeFixture } from "./agent-native/fixture.mjs";
+import {
+  authorizeOperation,
+  createReceipt,
+  createTask,
+  defineOperation,
+  recordEffectAttempt,
+  startRun,
+} from "./agent-native/execution.mjs";
+import { appendEvent } from "./agent-native/events.mjs";
+import {
+  createClaim,
+  createEvidenceLink,
+  createGovernanceDecision,
+  createValidationReport,
+} from "./agent-native/knowledge.mjs";
+import {
+  createProposal,
+  decideProposal,
+  promoteProposal,
+  verifyProposal,
+} from "./agent-native/learning.mjs";
+import { buildContextPackage, buildViewSnapshot } from "./agent-native/retrieval.mjs";
+import { createAgentCard } from "./agent-native/a2a-projection.mjs";
+import { projectAgUiEvents } from "./agent-native/agui-projection.mjs";
+import { agentNativeRegistry } from "./agent-native/registry.mjs";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const schemaDirectory = path.join(root, "consumer-reference", "agent-native", "schema");
+const rootSchema = JSON.parse(fs.readFileSync(path.join(schemaDirectory, "agent-native.schema.json"), "utf8"));
+const ajv = new Ajv2020({ allErrors: true, strict: true, strictRequired: false });
+addFormats(ajv);
+ajv.addSchema(rootSchema);
+
+const wrapperNames = ["identity", "manifest", "epistemic", "operation", "execution", "protocol-binding", "retrieval", "learning"];
+for (const name of wrapperNames) {
+  const schema = JSON.parse(fs.readFileSync(path.join(schemaDirectory, `${name}.schema.json`), "utf8"));
+  ajv.addSchema(schema);
+}
+
+const rows = [];
+function validator(name) {
+  const fn = ajv.getSchema(`${rootSchema.$id}#/$defs/${name}`);
+  assert.equal(typeof fn, "function", `missing validator for ${name}`);
+  return fn;
+}
+
+function valid(name, schemaName, value) {
+  const fn = validator(schemaName);
+  const ok = fn(value);
+  rows.push({ name, schema: schemaName, ok, errors: ok ? [] : fn.errors });
+  assert.equal(ok, true, `${name} did not satisfy ${schemaName}: ${JSON.stringify(fn.errors)}`);
+}
+
+function invalid(name, schemaName, value) {
+  const fn = validator(schemaName);
+  const ok = fn(value);
+  rows.push({ name, schema: schemaName, ok: !ok, errors: ok ? [] : fn.errors });
+  assert.equal(ok, false, `${name} unexpectedly satisfied ${schemaName}`);
+}
+
+function fixtureSchema(recordKind) {
+  return {
+    artifact_projection: "artifactProjection",
+    executable_fixture: "executableFixture",
+    profile_projection: "profileProjection",
+    agent_description: "agentDescription",
+    validator: "validator",
+    execution_receipt: "executionReceipt",
+    conformance_profile: "conformanceProfile",
+    claim: "claim",
+    evidence_link: "evidenceLink",
+    validation_report: "validationReport",
+    governance_decision: "governanceDecision",
+    policy_disposition: "policyDisposition",
+    operation: "operationSpec",
+  }[recordKind];
+}
+
+function buildSamples() {
+  const claim = createClaim({
+    actor: "sg:agent/schema-fixture",
+    stable_ref: "sg:claim/schema-fixture",
+    statement: "Closed schemas reject undeclared fields.",
+    subject_ref: "sg:profile/editorial-reference-profile",
+  });
+  const evidence = createEvidenceLink({
+    claim_ref: claim.stable_ref,
+    claim_version: claim.version_id,
+    independence_group: "schema-fixture",
+    polarity: "SUPPORT",
+    source_ref: "sg:artifact/schema-fixture",
+    stable_ref: "sg:evidence/schema-fixture",
+  });
+  const validation = createValidationReport({
+    claim_ref: claim.stable_ref,
+    claim_version: claim.version_id,
+    stable_ref: "sg:validation/schema-fixture",
+    status: "PASS",
+    suite: "schema-fixture",
+    validator_ref: "sg:validator/schema-fixture",
+    validator_version: "schema-validator@1",
+  });
+  const governance = createGovernanceDecision({
+    actor: "sg:governor/schema-fixture",
+    claim_ref: claim.stable_ref,
+    claim_version: claim.version_id,
+    decision: "ACCEPT",
+    policy_version: "schema-policy@1",
+    stable_ref: "sg:governance/schema-fixture",
+  });
+  const operation = defineOperation({
+    adapters: ["cli", "mcp"],
+    description: "Schema fixture operation.",
+    effect_class: "NONE",
+    input_schema: { additionalProperties: false, type: "object" },
+    name: "schema-fixture",
+    output_schema: { type: "object" },
+    required_capability: null,
+    stable_ref: "sg:operation/schema-fixture",
+  });
+  const grant = {
+    capability: "wiki.read",
+    operations: ["schema-fixture"],
+    resource_scope: ["sg:profile/*"],
+    subject: "agent:schema-fixture",
+  };
+  const authorization = authorizeOperation({
+    grant,
+    now: "2099-01-01T00:00:00.000Z",
+    operation,
+    resource: "sg:profile/editorial-reference-profile",
+    subject: "agent:schema-fixture",
+  });
+  const task = createTask({ intent: { operation: operation.name }, required_result: {}, stable_ref: "sg:task/schema-fixture" });
+  const run = startRun({ input: {}, run_id: "sg:run/schema-fixture", task });
+  const effect = recordEffectAttempt({ effect_class: "LOCAL", effect_id: "sg:effect/schema-fixture", run, task });
+  const receipt = createReceipt({ effects: [effect], input: {}, operation, output: {}, run, task, policy_decision: authorization.decision });
+  const event = appendEvent({ event: { event_id: "sg:event/schema-fixture", parents: [], payload: { task_id: task.task_id }, type: "task.created" }, events: [] })[0];
+  const snapshot = buildViewSnapshot({ heads: [event.event_id], members: [claim], snapshot_ref: "sg:view/schema-fixture", view_spec: { query: "schema" } });
+  const context = buildContextPackage({ budget: { tokens: 128 }, members: [claim], query: "schema", snapshot });
+  const proposal = createProposal({
+    changes: [{ path: "claim.statement", value: "A governed change." }],
+    claim: { stable_ref: claim.stable_ref, statement: claim.statement },
+    evidence: [evidence],
+    proposer: "agent:proposer",
+    stable_ref: "sg:proposal/schema-fixture",
+    validation: { status: "PASS", validator: "agent:validator" },
+  });
+  const proposalEvidence = proposal.evidence.map(({ version_id: _version_id, ...item }) => item);
+  const proposalValidation = (({ version_id: _version_id, ...item }) => item)(proposal.validation);
+  const verification = verifyProposal({ evidence: proposalEvidence, proposal, validation: proposalValidation, verifier: "agent:verifier" });
+  const decision = decideProposal({ decision: "ACCEPT", governance_decision: { actor: "agent:governor", decision: "ACCEPT" }, proposal, verification });
+  const promotion = promoteProposal({ decision, proposal, verification });
+  return { claim, evidence, validation, governance, operation, grant, authorization, task, run, effect, receipt, event, snapshot, context, proposal, verification, decision, promotion, card: createAgentCard(), agui: projectAgUiEvents({ task, run, text: "schema", toolCall: { id: "schema-tool", name: operation.name }, state: snapshot }) };
+}
+
+function run() {
+  valid("fixture manifest is closed", "manifest", agentNativeFixture.manifest);
+  for (const record of agentNativeFixture.records) {
+    const schemaName = fixtureSchema(record.record_kind);
+    assert.ok(schemaName, `fixture record kind ${record.record_kind} has no closed schema`);
+    valid(`fixture ${record.stable_ref}`, schemaName, record);
+  }
+  const sample = buildSamples();
+  const wrapperSamples = {
+    identity: sample.claim.stable_ref,
+    manifest: agentNativeFixture.manifest,
+    epistemic: sample.claim,
+    operation: sample.operation,
+    execution: sample.task,
+    "protocol-binding": { protocol: "a2a", protocolBindingId: "sg:binding/schema-fixture" },
+    retrieval: sample.snapshot,
+    learning: sample.proposal,
+  };
+  for (const name of wrapperNames) {
+    const fn = ajv.getSchema(`https://stylegallery.local/consumer-reference/agent-native/schema/${name}.schema.json`);
+    assert.equal(typeof fn, "function", `missing wrapper validator ${name}`);
+    const ok = fn(wrapperSamples[name]);
+    rows.push({ name: `wrapper ${name}`, schema: `${name}.schema.json`, ok, errors: ok ? [] : fn.errors });
+    assert.equal(ok, true, `wrapper ${name} rejected its representative value: ${JSON.stringify(fn.errors)}`);
+  }
+  for (const [name, schemaName] of Object.entries({ claim: "claim", evidence: "evidenceLink", validation: "validationReport", governance: "governanceDecision", operation: "operationSpec", grant: "capabilityGrant", authorization: "authorizationResult", task: "task", run: "run", effect: "effect", receipt: "invocationReceipt", event: "event", snapshot: "viewSnapshot", context: "contextPackage", proposal: "learningProposal", verification: "learningVerification", decision: "governanceDecision", promotionVersion: "governedVersion", promotionReceipt: "promotionReceipt", card: "agentCard", agui: "aguiProjection" })) valid(`generated ${name}`, schemaName, name === "promotionVersion" ? sample.promotion.version : name === "promotionReceipt" ? sample.promotion.receipt : sample[name]);
+  valid("generated A2A binding", "protocolBinding", sample.card ? { protocol: "a2a", protocolBindingId: "sg:binding/schema-fixture" } : {});
+  valid("generated self-description", "selfDescription", agentNativeRegistry.selfDescription);
+  invalid("manifest unknown property is rejected", "manifest", { ...agentNativeFixture.manifest, unexpected: true });
+  invalid("claim unknown property is rejected", "claim", { ...sample.claim, unexpected: true });
+  invalid("malformed StableRef is rejected", "claim", { ...sample.claim, stable_ref: "claim/schema-fixture" });
+  invalid("malformed VersionID is rejected", "claim", { ...sample.claim, version_id: `${sample.claim.stable_ref}@sha256:${"0".repeat(63)}z` });
+  return rows;
+}
+
+if (process.argv.slice(2).some((arg) => arg !== "--json")) {
+  process.stdout.write(`${JSON.stringify({ ok: false, status: "RED", failures: [{ code: "argument_unknown" }], results: [] }, null, 2)}\n`);
+  process.exitCode = 1;
+} else {
+  try {
+    const results = run();
+    const report = { contract: "agent-native-closed-schemas", ok: true, results };
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  } catch (error) {
+    const report = { contract: "agent-native-closed-schemas", ok: false, results: rows, failure: { message: error instanceof Error ? error.message : String(error) } };
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    process.exitCode = 1;
+  }
+}