stylegallery 0.1.0 → 0.1.2

package/scripts/test-agent-mcp.mjs

@@ -1,246 +0,0 @@
-#!/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

@@ -1,215 +0,0 @@
-#!/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;
-  }
-}