paper-mono 0.62.0

package/bin/chunks/chunk-ZX4GFXSY.js

@@ -0,0 +1,37 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __export,
+  __reExport,
+  __toESM
+};

package/bin/chunks/doctor-7DE4ASQO.js

@@ -0,0 +1,355 @@
+import {
+  assertMonoToolContractHandshake,
+  callPaperMcp,
+  paperLoadedToolContract,
+  paperTools,
+  renderPaperToolInventoryXml,
+  resolveMonoAgentHome,
+  resolveMonoContractRef,
+  resolvePaperAgentHome
+} from "./chunk-UHVY2TIH.js";
+import {
+  PACKAGE_DISTRIBUTION,
+  VERSION,
+  getPackageDir
+} from "./chunk-BGKLQ5Y6.js";
+import "./chunk-ZX4GFXSY.js";
+
+// src/doctor.ts
+import { existsSync as existsSync3 } from "node:fs";
+
+// ../../node_modules/@creative-int/mono/dist/tool-doctor.js
+import { existsSync } from "node:fs";
+var MONO_TOOLS_DOCTOR_VERSION = "mono-tools-doctor.v1";
+function createMonoToolDoctorReport(options) {
+  const { contract, contractPath, hash } = options.loadedContract;
+  const registered = new Set(options.registeredToolIds);
+  const fixtureProbe = options.fixtureProbe ?? existsSync;
+  const prerequisiteProbe = options.prerequisiteProbe ?? defaultProbe;
+  const sourcePackProbe = options.sourcePackProbe ?? canResolveSourcePack;
+  const safetyCard = options.safetyCard;
+  const safetyRows = new Map(safetyCard?.tools.map((tool) => [tool.tool, tool]) ?? []);
+  let handshake = "pass";
+  let handshakeError;
+  try {
+    assertMonoToolContractHandshake({
+      contract,
+      contractHash: hash,
+      registeredToolIds: options.registeredToolIds,
+      customDefinitionToolIds: options.customDefinitionToolIds,
+      prompt: options.prompt,
+      activeToolIds: options.activeToolIds,
+      agentHome: options.agentHome
+    });
+  } catch (error) {
+    handshake = "fail";
+    handshakeError = error instanceof Error ? error.message : String(error);
+  }
+  const tools = contract.tools.map((tool) => {
+    const fixturePaths = tool.cases.map((reference) => resolveMonoContractRef(contractPath, reference));
+    const fixtureOk = fixturePaths.every(fixtureProbe);
+    const handlerOk = registered.has(tool.id);
+    const sourcePackOk = !tool.sourcePack || sourcePackProbe(tool.sourcePack);
+    const safetyRow = safetyRows.get(tool.id);
+    const safetyRequired = Boolean(tool.safetyContract);
+    const safetyOk = !safetyRequired || safetyCard?.contractHash === hash && safetyRow?.status === "pass";
+    const prerequisiteChecks = buildPrerequisiteChecks(tool, prerequisiteProbe);
+    const credentialFailures = prerequisiteChecks.credentialChecks.filter((check) => check.required && !check.ok);
+    const integrationFailures = prerequisiteChecks.integrationChecks.filter((check) => check.required && !check.ok);
+    const checks = [
+      {
+        id: "handler",
+        ok: handlerOk,
+        required: true,
+        detail: handlerOk ? tool.handlerRef : `Missing registered definition for ${tool.id}`
+      },
+      {
+        id: "fixture",
+        ok: fixtureOk,
+        required: true,
+        detail: fixtureOk ? tool.cases.join(", ") : `Missing fixture: ${fixturePaths.filter((filePath) => !fixtureProbe(filePath)).join(", ")}`
+      },
+      {
+        id: "source-pack",
+        ok: sourcePackOk,
+        required: Boolean(tool.sourcePack),
+        detail: tool.sourcePack ?? "fork-local handler"
+      },
+      ...prerequisiteChecks.credentialChecks,
+      ...prerequisiteChecks.integrationChecks,
+      {
+        id: "contract-handshake",
+        ok: handshake === "pass",
+        required: true,
+        detail: handshakeError ?? hash
+      },
+      ...safetyRequired ? [
+        {
+          id: "safety-card",
+          ok: safetyOk,
+          required: true,
+          detail: safetyOk ? `${safetyCard?.schemaVersion} ${safetyRow?.declaredModes.join(", ")}` : safetyCard ? `Safety card is failing or stale (${safetyCard.contractHash})` : "Missing mono-safety-card.v1 evidence"
+        }
+      ] : []
+    ];
+    const broken = !handlerOk || !fixtureOk || !sourcePackOk || handshake === "fail" || integrationFailures.length > 0;
+    const safetyBroken = safetyRequired && !safetyOk;
+    const status = broken ? "BROKEN" : safetyBroken ? "BROKEN" : credentialFailures.length > 0 ? "CRED-GATED" : "OK";
+    const missingPrerequisites = [
+      ...prerequisiteChecks.missingCredentials,
+      ...prerequisiteChecks.missingIntegrations
+    ];
+    const safeNextCommand = options.safeNextCommand?.(tool, status, missingPrerequisites);
+    return {
+      tool: tool.id,
+      status,
+      contractHash: hash,
+      checks,
+      missingPrerequisites,
+      ...safeNextCommand ? { safeNextCommand } : {},
+      fixtureRefs: [...tool.cases],
+      secretValuesIncluded: false
+    };
+  });
+  return {
+    schemaVersion: MONO_TOOLS_DOCTOR_VERSION,
+    specialist: contract.specialist,
+    ownerCommand: contract.ownerCommand,
+    agentHome: resolveMonoAgentHome(contract, options.agentHome),
+    contractPath,
+    contractHash: hash,
+    handshake,
+    summary: {
+      OK: tools.filter((tool) => tool.status === "OK").length,
+      "CRED-GATED": tools.filter((tool) => tool.status === "CRED-GATED").length,
+      BROKEN: tools.filter((tool) => tool.status === "BROKEN").length
+    },
+    tools,
+    safety: createDoctorSafetySection(contract, hash, safetyCard),
+    secretValuesIncluded: false
+  };
+}
+function renderMonoToolDoctorReport(report) {
+  const lines = [
+    `${titleCase(report.specialist)} Tool Doctor`,
+    `contract: ${report.contractPath}`,
+    `hash: ${report.contractHash}`,
+    `agent home: ${report.agentHome}`,
+    `handshake: ${report.handshake.toUpperCase()}`,
+    `safety: ${report.safety.status.toUpperCase()} (${report.safety.passed} pass / ${report.safety.failed} fail)`,
+    ""
+  ];
+  for (const tool of report.tools) {
+    const verdict = tool.status === "OK" ? "PASS" : tool.status === "CRED-GATED" ? "WARN" : "FAIL";
+    lines.push(`${verdict} ${tool.tool} \u2014 ${tool.status}`);
+    if (tool.missingPrerequisites.length > 0) {
+      lines.push(`  missing: ${tool.missingPrerequisites.join(" | ")}`);
+    }
+    lines.push(`  fixture: ${tool.fixtureRefs.join(", ")}`);
+  }
+  lines.push("", `Summary: OK ${report.summary.OK} \xB7 CRED-GATED ${report.summary["CRED-GATED"]} \xB7 BROKEN ${report.summary.BROKEN}`);
+  return `${lines.join("\n")}
+`;
+}
+function createDoctorSafetySection(contract, contractHash, card) {
+  const declared = contract.tools.filter((tool) => tool.safetyContract);
+  if (declared.length === 0) {
+    return {
+      status: "not-declared",
+      schemaVersion: null,
+      contractHash,
+      verifiedAt: null,
+      verificationSource: null,
+      passed: 0,
+      failed: 0
+    };
+  }
+  if (!card) {
+    return {
+      status: "unverified",
+      schemaVersion: null,
+      contractHash,
+      verifiedAt: null,
+      verificationSource: null,
+      passed: 0,
+      failed: declared.length
+    };
+  }
+  const stale = card.contractHash !== contractHash;
+  return {
+    status: !stale && card.status === "pass" ? "pass" : "fail",
+    schemaVersion: card.schemaVersion,
+    contractHash: card.contractHash,
+    verifiedAt: card.verifiedAt,
+    verificationSource: card.verificationSource,
+    passed: stale ? 0 : card.summary.passed,
+    failed: stale ? declared.length : card.summary.failed
+  };
+}
+function buildPrerequisiteChecks(tool, probe) {
+  const allOf = tool.requires.allOf.map((name) => probePrerequisite(tool, "allOf", name, probe));
+  const anyOf = tool.requires.anyOf.map((name) => probePrerequisite(tool, "anyOf", name, probe));
+  const cli = tool.requires.cli.map((name) => probePrerequisite(tool, "cli", name, probe));
+  const endpoint = tool.requires.endpoint.map((name) => probePrerequisite(tool, "endpoint", name, probe));
+  const anyOfPass = anyOf.length === 0 || anyOf.some((check) => check.ok);
+  const credentialChecks = [
+    ...allOf.map((check) => ({ ...check, required: true })),
+    ...anyOf.length > 0 ? [
+      {
+        id: `any-of:${tool.requires.anyOf.join("|")}`,
+        ok: anyOfPass,
+        required: true,
+        detail: anyOfPass ? `configured one of: ${tool.requires.anyOf.join(", ")}` : `missing one of: ${tool.requires.anyOf.join(", ")}`
+      }
+    ] : []
+  ];
+  const integrationChecks = [
+    ...cli.map((check) => ({ ...check, required: true })),
+    ...endpoint.map((check) => ({ ...check, required: true }))
+  ];
+  return {
+    credentialChecks,
+    integrationChecks,
+    missingCredentials: [
+      ...allOf.filter((check) => !check.ok).map((check) => check.name),
+      ...!anyOfPass ? anyOf.map((check) => check.name) : []
+    ],
+    missingIntegrations: [...cli, ...endpoint].filter((check) => !check.ok).map((check) => check.name)
+  };
+}
+function probePrerequisite(tool, kind, name, probe) {
+  const result = probe({ kind, name, tool });
+  const normalized = typeof result === "boolean" ? { ok: result } : result;
+  return {
+    id: `${kind}:${name}`,
+    name,
+    ok: normalized.ok,
+    required: true,
+    detail: normalized.detail ?? name
+  };
+}
+function defaultProbe(input) {
+  if (input.kind === "allOf" || input.kind === "anyOf") {
+    return Boolean(process.env[input.name]);
+  }
+  return false;
+}
+function canResolveSourcePack(sourcePack) {
+  try {
+    import.meta.resolve(sourcePack);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function titleCase(value) {
+  return value.split(/[-_\s]+/).filter(Boolean).map((segment) => `${segment[0]?.toUpperCase() ?? ""}${segment.slice(1)}`).join(" ");
+}
+
+// src/safety-card.ts
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { join } from "node:path";
+var SAFETY_CARD_PATH = join(getPackageDir(), "tool-walk", "mono-safety-card.json");
+function loadMonoSafetyCard() {
+  if (!existsSync2(SAFETY_CARD_PATH)) return void 0;
+  return JSON.parse(readFileSync(SAFETY_CARD_PATH, "utf8"));
+}
+
+// src/doctor.ts
+var PAPER_MCP_URL = "http://127.0.0.1:29979/mcp";
+var PAPER_MCP_PROBE_TIMEOUT_MS = 3e3;
+var PAPER_BASIC_INFO_TOOL_ID = "paper_get_basic_info";
+async function isPaperMcpReachable(basicInfoToolId = PAPER_BASIC_INFO_TOOL_ID) {
+  const result = await callPaperMcp(basicInfoToolId, {}, void 0, PAPER_MCP_PROBE_TIMEOUT_MS);
+  if (result.ok) {
+    return {
+      ok: true,
+      endpointReachable: true,
+      detail: `Paper Desktop accepted ${result.desktopToolName} at ${PAPER_MCP_URL}`
+    };
+  }
+  return {
+    ok: false,
+    endpointReachable: result.failure === "contract",
+    detail: result.error
+  };
+}
+function paperDoctorExitCode(report) {
+  return report.summary.BROKEN > 0 ? 1 : 0;
+}
+function paperDoctorNextCommand(status, distribution = PACKAGE_DISTRIBUTION) {
+  if (status === "CRED-GATED") {
+    return "Open a file in Paper Desktop to start the MCP server at http://127.0.0.1:29979/mcp.";
+  }
+  if (status !== "BROKEN") return void 0;
+  return distribution === "public-bundle" ? `npm install --global paper-mono@${VERSION} && paper doctor --json` : "pnpm -C packages/mono test";
+}
+async function createPaperToolDoctorReport(options = {}) {
+  const reachable = await isPaperMcpReachable(options.basicInfoToolId);
+  const paperDomainTools = paperTools.filter((tool) => tool.name.startsWith("paper_"));
+  const agentHome = resolvePaperAgentHome();
+  const effectiveContract = {
+    ...paperLoadedToolContract,
+    contract: { ...paperLoadedToolContract.contract, agentHome }
+  };
+  return createMonoToolDoctorReport({
+    safetyCard: loadMonoSafetyCard(),
+    // The checked-in contract keeps ~/.paper/agent as the canonical default.
+    // Doctor validates the effective configured home without mutating that contract or its hash.
+    loadedContract: effectiveContract,
+    registeredToolIds: paperDomainTools.map((tool) => tool.name),
+    customDefinitionToolIds: paperDomainTools.map((tool) => tool.name),
+    prompt: `<domain_tools>${renderPaperToolInventoryXml()}</domain_tools>`,
+    agentHome,
+    prerequisiteProbe: ({ kind, name, tool }) => {
+      if (kind === "allOf") {
+        return {
+          ok: reachable.endpointReachable,
+          detail: reachable.endpointReachable ? `Paper Desktop endpoint reachable at ${PAPER_MCP_URL}` : reachable.detail
+        };
+      }
+      if (kind === "anyOf") {
+        return {
+          ok: true,
+          detail: "no any-of credential prerequisites for Paper MCP tools"
+        };
+      }
+      if (kind === "cli") {
+        if (name === "paper mono" && reachable.endpointReachable && !reachable.ok) {
+          return {
+            ok: false,
+            detail: `live Paper Desktop tool contract failed: ${reachable.detail}`
+          };
+        }
+        return {
+          ok: tool.cliFallback === null ? true : Boolean(tool.cliFallback?.trim()),
+          detail: tool.cliFallback ?? "registered tool; no CLI fallback"
+        };
+      }
+      if (kind === "endpoint") {
+        if (tool.id === "paper_mcp_reachability_check") {
+          return { ok: true, detail: "reachability-check tool does not require endpoint to be up" };
+        }
+        return {
+          ok: reachable.ok,
+          detail: reachable.detail
+        };
+      }
+      return { ok: false, detail: `unknown prerequisite kind ${kind}` };
+    },
+    sourcePackProbe: () => true,
+    // Paper tools are fork-local, no source packs
+    fixtureProbe: (filePath) => existsSync3(filePath),
+    safeNextCommand: (_tool, status) => paperDoctorNextCommand(status)
+  });
+}
+function renderPaperToolDoctorReport(report) {
+  return renderMonoToolDoctorReport(report);
+}
+export {
+  createPaperToolDoctorReport,
+  isPaperMcpReachable,
+  paperDoctorExitCode,
+  paperDoctorNextCommand,
+  renderPaperToolDoctorReport
+};