@letpeoplework/lighthouse-mcp-core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LetPeopleWork
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,129 @@
+type McpCorePackageContract = {
+    readonly name: "@letpeoplework/lighthouse-mcp-core";
+    readonly dependsOn: "@letpeoplework/lighthouse-client";
+    readonly transports: readonly ["stdio", "streamable-http"];
+};
+declare const getMcpCorePackageContract: () => McpCorePackageContract;
+type McpToolContent = {
+    readonly type: "text";
+    readonly text: string;
+};
+type McpToolResult = {
+    readonly isError: boolean;
+    readonly content: readonly McpToolContent[];
+};
+type McpToolDefinition = {
+    readonly name: "lighthouse.health.check" | "lighthouse.version.get" | "lighthouse.worktracking.list" | "lighthouse.worktracking.get" | "lighthouse.team.list" | "lighthouse.team.get" | "lighthouse.team.refresh" | "lighthouse.portfolio.list" | "lighthouse.portfolio.get" | "lighthouse.portfolio.refresh";
+    readonly description: string;
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: Record<string, never>;
+        readonly additionalProperties: false;
+    };
+};
+type McpRuntimeClient = {
+    readonly checkConnectivity: () => Promise<{
+        readonly category: "success" | "unreachable" | "misconfigured" | "unauthorized" | "dependency-failure" | "unexpected";
+        readonly reason?: string;
+    }>;
+    readonly getVersion: () => Promise<{
+        readonly ok: true;
+        readonly value: string;
+    } | {
+        readonly ok: false;
+        readonly error: {
+            readonly category: string;
+            readonly reason: string;
+        };
+    }>;
+    readonly listWorkTrackingConnections: () => Promise<{
+        readonly ok: true;
+        readonly value: readonly unknown[];
+    } | {
+        readonly ok: false;
+        readonly error: {
+            readonly category: string;
+            readonly reason: string;
+        };
+    }>;
+    readonly getWorkTrackingConnection: (id: number) => Promise<{
+        readonly ok: true;
+        readonly value: unknown;
+    } | {
+        readonly ok: false;
+        readonly error: {
+            readonly category: string;
+            readonly reason: string;
+        };
+    }>;
+    readonly listTeams: () => Promise<{
+        readonly ok: true;
+        readonly value: readonly unknown[];
+    } | {
+        readonly ok: false;
+        readonly error: {
+            readonly category: string;
+            readonly reason: string;
+        };
+    }>;
+    readonly getTeam: (id: number) => Promise<{
+        readonly ok: true;
+        readonly value: unknown;
+    } | {
+        readonly ok: false;
+        readonly error: {
+            readonly category: string;
+            readonly reason: string;
+        };
+    }>;
+    readonly refreshTeam: (id: number) => Promise<{
+        readonly ok: true;
+        readonly value: unknown;
+    } | {
+        readonly ok: false;
+        readonly error: {
+            readonly category: string;
+            readonly reason: string;
+        };
+    }>;
+    readonly listPortfolios: () => Promise<{
+        readonly ok: true;
+        readonly value: readonly unknown[];
+    } | {
+        readonly ok: false;
+        readonly error: {
+            readonly category: string;
+            readonly reason: string;
+        };
+    }>;
+    readonly getPortfolio: (id: number) => Promise<{
+        readonly ok: true;
+        readonly value: unknown;
+    } | {
+        readonly ok: false;
+        readonly error: {
+            readonly category: string;
+            readonly reason: string;
+        };
+    }>;
+    readonly refreshPortfolio: (id: number) => Promise<{
+        readonly ok: true;
+        readonly value: unknown;
+    } | {
+        readonly ok: false;
+        readonly error: {
+            readonly category: string;
+            readonly reason: string;
+        };
+    }>;
+};
+type McpCoreRuntimeDependencies = {
+    readonly createClient: () => McpRuntimeClient;
+};
+type McpCoreRuntime = {
+    readonly listTools: () => readonly McpToolDefinition[];
+    readonly callTool: (name: string, argumentsPayload: unknown) => Promise<McpToolResult>;
+};
+declare const createMcpCoreRuntime: (dependencies: McpCoreRuntimeDependencies) => McpCoreRuntime;
+
+export { type McpCorePackageContract, type McpCoreRuntime, type McpCoreRuntimeDependencies, type McpToolDefinition, type McpToolResult, createMcpCoreRuntime, getMcpCorePackageContract };

package/dist/index.d.ts

@@ -0,0 +1,129 @@
+type McpCorePackageContract = {
+    readonly name: "@letpeoplework/lighthouse-mcp-core";
+    readonly dependsOn: "@letpeoplework/lighthouse-client";
+    readonly transports: readonly ["stdio", "streamable-http"];
+};
+declare const getMcpCorePackageContract: () => McpCorePackageContract;
+type McpToolContent = {
+    readonly type: "text";
+    readonly text: string;
+};
+type McpToolResult = {
+    readonly isError: boolean;
+    readonly content: readonly McpToolContent[];
+};
+type McpToolDefinition = {
+    readonly name: "lighthouse.health.check" | "lighthouse.version.get" | "lighthouse.worktracking.list" | "lighthouse.worktracking.get" | "lighthouse.team.list" | "lighthouse.team.get" | "lighthouse.team.refresh" | "lighthouse.portfolio.list" | "lighthouse.portfolio.get" | "lighthouse.portfolio.refresh";
+    readonly description: string;
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: Record<string, never>;
+        readonly additionalProperties: false;
+    };
+};
+type McpRuntimeClient = {
+    readonly checkConnectivity: () => Promise<{
+        readonly category: "success" | "unreachable" | "misconfigured" | "unauthorized" | "dependency-failure" | "unexpected";
+        readonly reason?: string;
+    }>;
+    readonly getVersion: () => Promise<{
+        readonly ok: true;
+        readonly value: string;
+    } | {
+        readonly ok: false;
+        readonly error: {
+            readonly category: string;
+            readonly reason: string;
+        };
+    }>;
+    readonly listWorkTrackingConnections: () => Promise<{
+        readonly ok: true;
+        readonly value: readonly unknown[];
+    } | {
+        readonly ok: false;
+        readonly error: {
+            readonly category: string;
+            readonly reason: string;
+        };
+    }>;
+    readonly getWorkTrackingConnection: (id: number) => Promise<{
+        readonly ok: true;
+        readonly value: unknown;
+    } | {
+        readonly ok: false;
+        readonly error: {
+            readonly category: string;
+            readonly reason: string;
+        };
+    }>;
+    readonly listTeams: () => Promise<{
+        readonly ok: true;
+        readonly value: readonly unknown[];
+    } | {
+        readonly ok: false;
+        readonly error: {
+            readonly category: string;
+            readonly reason: string;
+        };
+    }>;
+    readonly getTeam: (id: number) => Promise<{
+        readonly ok: true;
+        readonly value: unknown;
+    } | {
+        readonly ok: false;
+        readonly error: {
+            readonly category: string;
+            readonly reason: string;
+        };
+    }>;
+    readonly refreshTeam: (id: number) => Promise<{
+        readonly ok: true;
+        readonly value: unknown;
+    } | {
+        readonly ok: false;
+        readonly error: {
+            readonly category: string;
+            readonly reason: string;
+        };
+    }>;
+    readonly listPortfolios: () => Promise<{
+        readonly ok: true;
+        readonly value: readonly unknown[];
+    } | {
+        readonly ok: false;
+        readonly error: {
+            readonly category: string;
+            readonly reason: string;
+        };
+    }>;
+    readonly getPortfolio: (id: number) => Promise<{
+        readonly ok: true;
+        readonly value: unknown;
+    } | {
+        readonly ok: false;
+        readonly error: {
+            readonly category: string;
+            readonly reason: string;
+        };
+    }>;
+    readonly refreshPortfolio: (id: number) => Promise<{
+        readonly ok: true;
+        readonly value: unknown;
+    } | {
+        readonly ok: false;
+        readonly error: {
+            readonly category: string;
+            readonly reason: string;
+        };
+    }>;
+};
+type McpCoreRuntimeDependencies = {
+    readonly createClient: () => McpRuntimeClient;
+};
+type McpCoreRuntime = {
+    readonly listTools: () => readonly McpToolDefinition[];
+    readonly callTool: (name: string, argumentsPayload: unknown) => Promise<McpToolResult>;
+};
+declare const createMcpCoreRuntime: (dependencies: McpCoreRuntimeDependencies) => McpCoreRuntime;
+
+export { type McpCorePackageContract, type McpCoreRuntime, type McpCoreRuntimeDependencies, type McpToolDefinition, type McpToolResult, createMcpCoreRuntime, getMcpCorePackageContract };

package/dist/index.js

@@ -0,0 +1,281 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createMcpCoreRuntime: () => createMcpCoreRuntime,
+  getMcpCorePackageContract: () => getMcpCorePackageContract
+});
+module.exports = __toCommonJS(index_exports);
+var getMcpCorePackageContract = () => ({
+  name: "@letpeoplework/lighthouse-mcp-core",
+  dependsOn: "@letpeoplework/lighthouse-client",
+  transports: ["stdio", "streamable-http"]
+});
+var toolDefinitions = [
+  {
+    name: "lighthouse.health.check",
+    description: "Validate Lighthouse API connectivity.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "lighthouse.version.get",
+    description: "Get Lighthouse version from /api/v1/version.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "lighthouse.worktracking.list",
+    description: "List work-tracking system connections.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "lighthouse.worktracking.get",
+    description: "Get one work-tracking system connection by id.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "lighthouse.team.list",
+    description: "List teams.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "lighthouse.team.get",
+    description: "Get one team by id.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "lighthouse.team.refresh",
+    description: "Trigger a refresh for one team.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "lighthouse.portfolio.list",
+    description: "List portfolios.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "lighthouse.portfolio.get",
+    description: "Get one portfolio by id.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "lighthouse.portfolio.refresh",
+    description: "Trigger a refresh for one portfolio.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  }
+];
+var getSuccessToolResult = (text) => ({
+  isError: false,
+  content: [
+    {
+      type: "text",
+      text
+    }
+  ]
+});
+var getErrorToolResult = (text) => ({
+  isError: true,
+  content: [
+    {
+      type: "text",
+      text
+    }
+  ]
+});
+var getNumericId = (argumentsPayload) => {
+  if (typeof argumentsPayload !== "object" || argumentsPayload === null || Array.isArray(argumentsPayload)) {
+    return null;
+  }
+  const value = argumentsPayload.id;
+  if (typeof value === "number" && Number.isInteger(value)) {
+    return value;
+  }
+  return null;
+};
+var createMcpCoreRuntime = (dependencies) => ({
+  listTools: () => toolDefinitions,
+  callTool: async (name, argumentsPayload) => {
+    const client = dependencies.createClient();
+    if (name === "lighthouse.health.check") {
+      const health = await client.checkConnectivity();
+      if (health.category === "success") {
+        return getSuccessToolResult("connectivity: success");
+      }
+      return getErrorToolResult(
+        `connectivity: ${health.category}${health.reason !== void 0 ? ` (${health.reason})` : ""}`
+      );
+    }
+    if (name === "lighthouse.version.get") {
+      const version = await client.getVersion();
+      if (version.ok) {
+        return getSuccessToolResult(`version: ${version.value}`);
+      }
+      return getErrorToolResult(
+        `version: ${version.error.category} (${version.error.reason})`
+      );
+    }
+    if (name === "lighthouse.worktracking.list") {
+      const connections = await client.listWorkTrackingConnections();
+      if (connections.ok) {
+        return getSuccessToolResult(
+          `worktracking: ${JSON.stringify(connections.value)}`
+        );
+      }
+      return getErrorToolResult(
+        `worktracking: ${connections.error.category} (${connections.error.reason})`
+      );
+    }
+    if (name === "lighthouse.worktracking.get") {
+      const id = getNumericId(argumentsPayload);
+      if (id === null) {
+        return getErrorToolResult("worktracking: invalid id");
+      }
+      const connection = await client.getWorkTrackingConnection(id);
+      if (connection.ok) {
+        return getSuccessToolResult(
+          `worktracking: ${JSON.stringify(connection.value)}`
+        );
+      }
+      return getErrorToolResult(
+        `worktracking: ${connection.error.category} (${connection.error.reason})`
+      );
+    }
+    if (name === "lighthouse.team.list") {
+      const teams = await client.listTeams();
+      if (teams.ok) {
+        return getSuccessToolResult(`teams: ${JSON.stringify(teams.value)}`);
+      }
+      return getErrorToolResult(
+        `teams: ${teams.error.category} (${teams.error.reason})`
+      );
+    }
+    if (name === "lighthouse.team.get") {
+      const id = getNumericId(argumentsPayload);
+      if (id === null) {
+        return getErrorToolResult("team: invalid id");
+      }
+      const team = await client.getTeam(id);
+      if (team.ok) {
+        return getSuccessToolResult(`team: ${JSON.stringify(team.value)}`);
+      }
+      return getErrorToolResult(
+        `team: ${team.error.category} (${team.error.reason})`
+      );
+    }
+    if (name === "lighthouse.team.refresh") {
+      const id = getNumericId(argumentsPayload);
+      if (id === null) {
+        return getErrorToolResult("team: invalid id");
+      }
+      const result = await client.refreshTeam(id);
+      if (result.ok) {
+        return getSuccessToolResult(`team refreshed: ${id}`);
+      }
+      return getErrorToolResult(
+        `team refresh: ${result.error.category} (${result.error.reason})`
+      );
+    }
+    if (name === "lighthouse.portfolio.list") {
+      const portfolios = await client.listPortfolios();
+      if (portfolios.ok) {
+        return getSuccessToolResult(
+          `portfolios: ${JSON.stringify(portfolios.value)}`
+        );
+      }
+      return getErrorToolResult(
+        `portfolios: ${portfolios.error.category} (${portfolios.error.reason})`
+      );
+    }
+    if (name === "lighthouse.portfolio.get") {
+      const id = getNumericId(argumentsPayload);
+      if (id === null) {
+        return getErrorToolResult("portfolio: invalid id");
+      }
+      const portfolio = await client.getPortfolio(id);
+      if (portfolio.ok) {
+        return getSuccessToolResult(
+          `portfolio: ${JSON.stringify(portfolio.value)}`
+        );
+      }
+      return getErrorToolResult(
+        `portfolio: ${portfolio.error.category} (${portfolio.error.reason})`
+      );
+    }
+    if (name === "lighthouse.portfolio.refresh") {
+      const id = getNumericId(argumentsPayload);
+      if (id === null) {
+        return getErrorToolResult("portfolio: invalid id");
+      }
+      const result = await client.refreshPortfolio(id);
+      if (result.ok) {
+        return getSuccessToolResult(`portfolio refreshed: ${id}`);
+      }
+      return getErrorToolResult(
+        `portfolio refresh: ${result.error.category} (${result.error.reason})`
+      );
+    }
+    return getErrorToolResult(`Unknown tool: ${name}`);
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMcpCoreRuntime,
+  getMcpCorePackageContract
+});

package/dist/index.mjs

@@ -0,0 +1,255 @@
+// src/index.ts
+var getMcpCorePackageContract = () => ({
+  name: "@letpeoplework/lighthouse-mcp-core",
+  dependsOn: "@letpeoplework/lighthouse-client",
+  transports: ["stdio", "streamable-http"]
+});
+var toolDefinitions = [
+  {
+    name: "lighthouse.health.check",
+    description: "Validate Lighthouse API connectivity.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "lighthouse.version.get",
+    description: "Get Lighthouse version from /api/v1/version.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "lighthouse.worktracking.list",
+    description: "List work-tracking system connections.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "lighthouse.worktracking.get",
+    description: "Get one work-tracking system connection by id.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "lighthouse.team.list",
+    description: "List teams.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "lighthouse.team.get",
+    description: "Get one team by id.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "lighthouse.team.refresh",
+    description: "Trigger a refresh for one team.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "lighthouse.portfolio.list",
+    description: "List portfolios.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "lighthouse.portfolio.get",
+    description: "Get one portfolio by id.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  },
+  {
+    name: "lighthouse.portfolio.refresh",
+    description: "Trigger a refresh for one portfolio.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    }
+  }
+];
+var getSuccessToolResult = (text) => ({
+  isError: false,
+  content: [
+    {
+      type: "text",
+      text
+    }
+  ]
+});
+var getErrorToolResult = (text) => ({
+  isError: true,
+  content: [
+    {
+      type: "text",
+      text
+    }
+  ]
+});
+var getNumericId = (argumentsPayload) => {
+  if (typeof argumentsPayload !== "object" || argumentsPayload === null || Array.isArray(argumentsPayload)) {
+    return null;
+  }
+  const value = argumentsPayload.id;
+  if (typeof value === "number" && Number.isInteger(value)) {
+    return value;
+  }
+  return null;
+};
+var createMcpCoreRuntime = (dependencies) => ({
+  listTools: () => toolDefinitions,
+  callTool: async (name, argumentsPayload) => {
+    const client = dependencies.createClient();
+    if (name === "lighthouse.health.check") {
+      const health = await client.checkConnectivity();
+      if (health.category === "success") {
+        return getSuccessToolResult("connectivity: success");
+      }
+      return getErrorToolResult(
+        `connectivity: ${health.category}${health.reason !== void 0 ? ` (${health.reason})` : ""}`
+      );
+    }
+    if (name === "lighthouse.version.get") {
+      const version = await client.getVersion();
+      if (version.ok) {
+        return getSuccessToolResult(`version: ${version.value}`);
+      }
+      return getErrorToolResult(
+        `version: ${version.error.category} (${version.error.reason})`
+      );
+    }
+    if (name === "lighthouse.worktracking.list") {
+      const connections = await client.listWorkTrackingConnections();
+      if (connections.ok) {
+        return getSuccessToolResult(
+          `worktracking: ${JSON.stringify(connections.value)}`
+        );
+      }
+      return getErrorToolResult(
+        `worktracking: ${connections.error.category} (${connections.error.reason})`
+      );
+    }
+    if (name === "lighthouse.worktracking.get") {
+      const id = getNumericId(argumentsPayload);
+      if (id === null) {
+        return getErrorToolResult("worktracking: invalid id");
+      }
+      const connection = await client.getWorkTrackingConnection(id);
+      if (connection.ok) {
+        return getSuccessToolResult(
+          `worktracking: ${JSON.stringify(connection.value)}`
+        );
+      }
+      return getErrorToolResult(
+        `worktracking: ${connection.error.category} (${connection.error.reason})`
+      );
+    }
+    if (name === "lighthouse.team.list") {
+      const teams = await client.listTeams();
+      if (teams.ok) {
+        return getSuccessToolResult(`teams: ${JSON.stringify(teams.value)}`);
+      }
+      return getErrorToolResult(
+        `teams: ${teams.error.category} (${teams.error.reason})`
+      );
+    }
+    if (name === "lighthouse.team.get") {
+      const id = getNumericId(argumentsPayload);
+      if (id === null) {
+        return getErrorToolResult("team: invalid id");
+      }
+      const team = await client.getTeam(id);
+      if (team.ok) {
+        return getSuccessToolResult(`team: ${JSON.stringify(team.value)}`);
+      }
+      return getErrorToolResult(
+        `team: ${team.error.category} (${team.error.reason})`
+      );
+    }
+    if (name === "lighthouse.team.refresh") {
+      const id = getNumericId(argumentsPayload);
+      if (id === null) {
+        return getErrorToolResult("team: invalid id");
+      }
+      const result = await client.refreshTeam(id);
+      if (result.ok) {
+        return getSuccessToolResult(`team refreshed: ${id}`);
+      }
+      return getErrorToolResult(
+        `team refresh: ${result.error.category} (${result.error.reason})`
+      );
+    }
+    if (name === "lighthouse.portfolio.list") {
+      const portfolios = await client.listPortfolios();
+      if (portfolios.ok) {
+        return getSuccessToolResult(
+          `portfolios: ${JSON.stringify(portfolios.value)}`
+        );
+      }
+      return getErrorToolResult(
+        `portfolios: ${portfolios.error.category} (${portfolios.error.reason})`
+      );
+    }
+    if (name === "lighthouse.portfolio.get") {
+      const id = getNumericId(argumentsPayload);
+      if (id === null) {
+        return getErrorToolResult("portfolio: invalid id");
+      }
+      const portfolio = await client.getPortfolio(id);
+      if (portfolio.ok) {
+        return getSuccessToolResult(
+          `portfolio: ${JSON.stringify(portfolio.value)}`
+        );
+      }
+      return getErrorToolResult(
+        `portfolio: ${portfolio.error.category} (${portfolio.error.reason})`
+      );
+    }
+    if (name === "lighthouse.portfolio.refresh") {
+      const id = getNumericId(argumentsPayload);
+      if (id === null) {
+        return getErrorToolResult("portfolio: invalid id");
+      }
+      const result = await client.refreshPortfolio(id);
+      if (result.ok) {
+        return getSuccessToolResult(`portfolio refreshed: ${id}`);
+      }
+      return getErrorToolResult(
+        `portfolio refresh: ${result.error.category} (${result.error.reason})`
+      );
+    }
+    return getErrorToolResult(`Unknown tool: ${name}`);
+  }
+});
+export {
+  createMcpCoreRuntime,
+  getMcpCorePackageContract
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@letpeoplework/lighthouse-mcp-core",
+  "version": "0.1.0",
+  "description": "Shared MCP semantics for Lighthouse",
+  "repository": "https://github.com/LetPeopleWork/lighthouse-clients",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@letpeoplework/lighthouse-client": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "clean": "rimraf dist"
+  }
+}