@skillit/target-fastmcp 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-present Pradeep Mouli
+
+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/README.md

@@ -0,0 +1,117 @@
+# @skillit/target-fastmcp
+
+> CLI-as-proxy invocation-target adapter for `@skillit/mcp`. Emits shell-command skills that use the [fastmcp](https://gofastmcp.com) Python CLI to invoke MCP tools.
+
+Pairs with [`@skillit/mcp`](../mcp/). Where `@skillit/target-mcp-protocol` emits `mcp:` frontmatter for harnesses that hold an MCP session natively, `@skillit/target-fastmcp` emits a SKILL.md whose body is a series of shell commands the agent runs through its standard shell tool. The CLI terminates the MCP protocol at the shell boundary; the agent never sees MCP.
+
+Target CLI: **`fastmcp@^2`** (Python, installed via `pip install fastmcp`).
+
+---
+
+## Install
+
+```bash
+npm install --save-dev @skillit/target-fastmcp
+```
+
+The adapter is loaded by `@skillit/mcp` on demand when you pass `--invocation cli:fastmcp`. Consumers of the rendered SKILL.md additionally need a Python environment with `fastmcp` installed — see Setup commands below.
+
+---
+
+## When to pick this target
+
+Pick `cli:fastmcp` when **the agent harness has a shell tool but cannot speak MCP natively**, AND you prefer the Python `fastmcp` CLI to Node-based alternatives. Common reasons:
+
+- Your team already deploys Python; another Node CLI would be the only Node dep.
+- You want to use fastmcp's richer Python-side ergonomics (server authoring, debugging) end-to-end.
+- The harness machine has Python pre-installed but not Node.
+
+If neither of those applies, `cli:mcpc` is the lighter alternative — see [`@skillit/target-mcpc`](../target-mcpc/).
+
+---
+
+## What it emits
+
+A `SKILL.md` body whose Tools section pairs each MCP tool with its concrete shell invocation:
+
+````markdown
+## search
+
+Search the index.
+
+```sh
+pyfastmcp call my-server search query=<value>
+```
+
+### Parameters
+
+| MCP Name | CLI Flag/Key  | Type   | Required | Description  |
+| -------- | ------------- | ------ | -------- | ------------ |
+| query    | query=<value> | string | yes      | Query string |
+````
+
+Plus a Setup section with one-time install + connection registration commands, and a `generated-by:` frontmatter block carrying the adapter fingerprint.
+
+---
+
+## Argument encoding
+
+The fastmcp CLI parses each positional after `call <server> <tool>` as `key=value`. Unlike mcpc, fastmcp does not currently expose a typed-literal form (`:=`) — every value is passed as a string and the server-side schema validator coerces. The adapter:
+
+- Emits `key=<value>` for every parameter (Tier 1).
+- Falls back to a single `--input-json '<JSON-payload>'` flag when any parameter is a complex object or array that wouldn't survive shell tokenization (Tier 3).
+
+The Parameters table in the rendered Markdown shows the literal CLI form so the consumer can copy-paste with confidence.
+
+---
+
+## Setup commands
+
+The Setup section the adapter emits looks like this (verbatim):
+
+```sh
+# 1. Install fastmcp (Python CLI for invoking MCP servers; tested with fastmcp 2.x)
+pip install fastmcp
+
+# 2. Register this server (the renderer emits `pyfastmcp connect`, fastmcp's
+#    Python CLI binary name; some distributions alias it to `fastmcp`)
+pyfastmcp connect <skill-name> -- <launchCommand>
+
+# 3. (Optional) Verify the registration
+pyfastmcp list
+```
+
+---
+
+## Adapter contract
+
+| Field                        | Value                                         |
+| ---------------------------- | --------------------------------------------- |
+| `target`                     | `'cli:fastmcp'`                               |
+| `fingerprint.adapter`        | `'@skillit/target-fastmcp'`                   |
+| `fingerprint.version`        | This package's `version` from `package.json`. |
+| `fingerprint.targetCliRange` | `'fastmcp@^2'`                                |
+
+Future major versions of fastmcp that change the `call` arg shape MUST bump this adapter's major version and update `targetCliRange` so the freshness audit (M5) can detect drift.
+
+---
+
+## Programmatic use
+
+```ts
+import FastMcpAdapter from '@skillit/target-fastmcp';
+import { renderSkill } from '@skillit/core';
+
+const rendered = await renderSkill(skill, { invocation: FastMcpAdapter });
+```
+
+---
+
+## Further reading
+
+- [`@skillit/mcp` README](../mcp/README.md) — host package, CLI usage.
+- [`docs/adapter-authoring.md`](../mcp/docs/adapter-authoring.md) — building your own invocation adapter.
+
+## License
+
+MIT

package/dist/args.d.ts

@@ -0,0 +1,61 @@
+/**
+ * fastmcp argument encoder — converts classifier output into fastmcp CLI argv shape.
+ *
+ * @remarks
+ * fastmcp (the Python `fastmcp` / `pyfastmcp call` CLI,
+ * https://gofastmcp.com) accepts tool arguments in a single uniform form:
+ *
+ * - `key=value` — fastmcp parses the right-hand side based on the tool's
+ *   declared schema, so we do NOT use a typed `key:=value` variant the way
+ *   mcpc does. Numbers, booleans, enums, and string-arrays all share the
+ *   same `key=<placeholder>` shape; the placeholder text describes the
+ *   accepted value(s) for human readers.
+ *
+ * For Tier 3 fallback (anything we couldn't safely flatten), we emit a
+ * single `--input-json '<JSON-payload>'` argument. fastmcp's structured-input
+ * convention for passing whole-object payloads is the `--input-json` flag.
+ * The payload is a placeholder — this encoder is for documentation
+ * rendering, not runtime invocation, so actual values are substituted by
+ * the consumer at call time.
+ *
+ * @module args
+ */
+import type { ParameterPlan } from '@skillit/mcp';
+/** Encoder result — separated into normal flags vs Tier 3 fallback. */
+export interface EncodedArgs {
+    /**
+     * Encoded arguments for Tier 1 + Tier 2 plans, one string per CLI token.
+     * Order matches insertion order of the input plan map (which itself
+     * preserves classifier walk order).
+     */
+    tier12: string[];
+    /**
+     * When ANY plan in the input has `tier === 3`, this is the single
+     * `--input-json '<JSON-payload>'` token string. Otherwise `null`. fastmcp
+     * accepts one `--input-json` per call carrying the structural arguments
+     * that couldn't be flattened into typed flags.
+     */
+    tier3Fallback: string | null;
+}
+/**
+ * Encode a classifier plan map as fastmcp argv tokens (documentation form).
+ *
+ * Encoding rules per tier:
+ *
+ * - Tier 1 + `type === 'scalar'` + scalarType `string` → `<path>=<value>`.
+ * - Tier 1 + `type === 'scalar'` + scalarType `number`/`integer` → `<path>=<value>`.
+ * - Tier 1 + `type === 'scalar'` + scalarType `boolean` → `<path>=<true|false>`.
+ * - Tier 1 + `type === 'enum'` → `<path>=<one-of-...>`.
+ * - Tier 1 + `type === 'string-array'` → `<path>=<comma-separated>`
+ *   (fastmcp accepts CSV for repeatable string args).
+ * - Tier 2 → same as the leaf's Tier 1 form, with `<path>` joined by `.`.
+ * - Tier 3 → contributes nothing to `tier12`; sets `tier3Fallback`.
+ *
+ * Path is always joined with `.` (matches mcpc convention; fastmcp resolves
+ * dotted keys against nested schema properties).
+ *
+ * @param plan - classifier output (`Map<string, ParameterPlan>`)
+ * @returns split encoding result — Tier 1/2 tokens + optional Tier 3 fallback string
+ */
+export declare function encodeFastMcpArgs(plan: Map<string, ParameterPlan>): EncodedArgs;
+//# sourceMappingURL=args.d.ts.map

package/dist/args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../src/args.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAElD,uEAAuE;AACvE,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB;;;;;OAKG;IACH,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,GAAG,WAAW,CAiB/E"}

package/dist/args.js

@@ -0,0 +1,85 @@
+/**
+ * fastmcp argument encoder — converts classifier output into fastmcp CLI argv shape.
+ *
+ * @remarks
+ * fastmcp (the Python `fastmcp` / `pyfastmcp call` CLI,
+ * https://gofastmcp.com) accepts tool arguments in a single uniform form:
+ *
+ * - `key=value` — fastmcp parses the right-hand side based on the tool's
+ *   declared schema, so we do NOT use a typed `key:=value` variant the way
+ *   mcpc does. Numbers, booleans, enums, and string-arrays all share the
+ *   same `key=<placeholder>` shape; the placeholder text describes the
+ *   accepted value(s) for human readers.
+ *
+ * For Tier 3 fallback (anything we couldn't safely flatten), we emit a
+ * single `--input-json '<JSON-payload>'` argument. fastmcp's structured-input
+ * convention for passing whole-object payloads is the `--input-json` flag.
+ * The payload is a placeholder — this encoder is for documentation
+ * rendering, not runtime invocation, so actual values are substituted by
+ * the consumer at call time.
+ *
+ * @module args
+ */
+/**
+ * Encode a classifier plan map as fastmcp argv tokens (documentation form).
+ *
+ * Encoding rules per tier:
+ *
+ * - Tier 1 + `type === 'scalar'` + scalarType `string` → `<path>=<value>`.
+ * - Tier 1 + `type === 'scalar'` + scalarType `number`/`integer` → `<path>=<value>`.
+ * - Tier 1 + `type === 'scalar'` + scalarType `boolean` → `<path>=<true|false>`.
+ * - Tier 1 + `type === 'enum'` → `<path>=<one-of-...>`.
+ * - Tier 1 + `type === 'string-array'` → `<path>=<comma-separated>`
+ *   (fastmcp accepts CSV for repeatable string args).
+ * - Tier 2 → same as the leaf's Tier 1 form, with `<path>` joined by `.`.
+ * - Tier 3 → contributes nothing to `tier12`; sets `tier3Fallback`.
+ *
+ * Path is always joined with `.` (matches mcpc convention; fastmcp resolves
+ * dotted keys against nested schema properties).
+ *
+ * @param plan - classifier output (`Map<string, ParameterPlan>`)
+ * @returns split encoding result — Tier 1/2 tokens + optional Tier 3 fallback string
+ */
+export function encodeFastMcpArgs(plan) {
+    const tier12 = [];
+    let hasTier3 = false;
+    for (const [, p] of plan) {
+        if (p.tier === 3) {
+            hasTier3 = true;
+            continue;
+        }
+        const key = p.path.join('.');
+        tier12.push(encodeOne(key, p));
+    }
+    return {
+        tier12,
+        tier3Fallback: hasTier3 ? `--input-json '<JSON-payload>'` : null
+    };
+}
+function encodeOne(key, plan) {
+    // Tier 1/2 leaves only — Tier 3 (`type: 'json'`) short-circuited in the
+    // caller. We still cover the `'json'` arm explicitly so `switch` is
+    // exhaustive and TS proves no arm is missed.
+    switch (plan.type) {
+        case 'scalar': {
+            if (plan.scalarType === 'boolean')
+                return `${key}=<true|false>`;
+            // string / number / integer — fastmcp parses by schema.
+            return `${key}=<value>`;
+        }
+        case 'enum':
+            // DU guarantees `plan.enum.length >= 1`.
+            return `${key}=<one-of-${plan.enum.join('|')}>`;
+        case 'string-array':
+            return `${key}=<comma-separated>`;
+        case 'json':
+            // Defensive: callers filter Tier 3 above. fastmcp accepts
+            // `key=<value>` as a JSON literal when the schema demands it.
+            return `${key}=<value>`;
+        default: {
+            const _exhaustive = plan;
+            throw new Error(`encodeOne: unhandled ParameterPlan arm: ${JSON.stringify(_exhaustive)}`);
+        }
+    }
+}
+//# sourceMappingURL=args.js.map

package/dist/args.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"args.js","sourceRoot":"","sources":["../src/args.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAqBH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAgC;IAChE,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,IAAI,QAAQ,GAAG,KAAK,CAAC;IAErB,KAAK,MAAM,CAAC,EAAE,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC;QACzB,IAAI,CAAC,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;YACjB,QAAQ,GAAG,IAAI,CAAC;YAChB,SAAS;QACX,CAAC;QACD,MAAM,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC7B,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;IACjC,CAAC;IAED,OAAO;QACL,MAAM;QACN,aAAa,EAAE,QAAQ,CAAC,CAAC,CAAC,+BAA+B,CAAC,CAAC,CAAC,IAAI;KACjE,CAAC;AACJ,CAAC;AAED,SAAS,SAAS,CAAC,GAAW,EAAE,IAAmB;IACjD,wEAAwE;IACxE,oEAAoE;IACpE,6CAA6C;IAC7C,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS;gBAAE,OAAO,GAAG,GAAG,eAAe,CAAC;YAChE,wDAAwD;YACxD,OAAO,GAAG,GAAG,UAAU,CAAC;QAC1B,CAAC;QACD,KAAK,MAAM;YACT,yCAAyC;YACzC,OAAO,GAAG,GAAG,YAAY,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;QAClD,KAAK,cAAc;YACjB,OAAO,GAAG,GAAG,oBAAoB,CAAC;QACpC,KAAK,MAAM;YACT,0DAA0D;YAC1D,8DAA8D;YAC9D,OAAO,GAAG,GAAG,UAAU,CAAC;QAC1B,OAAO,CAAC,CAAC,CAAC;YACR,MAAM,WAAW,GAAU,IAAI,CAAC;YAChC,MAAM,IAAI,KAAK,CAAC,2CAA2C,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;QAC5F,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * `@skillit/target-fastmcp` — CLI-as-proxy invocation-target adapter.
+ *
+ * Resolved by `@skillit/mcp`'s adapter loader when target `cli:fastmcp` is
+ * requested. Emits SKILL.md output that routes tool calls through the
+ * Python `fastmcp` CLI, making the skill consumable by any agent with a
+ * shell tool (rather than only MCP-native harnesses).
+ *
+ * @packageDocumentation
+ */
+export { FastMcpAdapter } from './render.js';
+export { encodeFastMcpArgs } from './args.js';
+export type { EncodedArgs } from './args.js';
+export { renderFastMcpSetup } from './setup.js';
+export type { StdioLaunchCommand, HttpLaunchEndpoint } from './setup.js';
+export { PACKAGE_VERSION } from './version.js';
+import { FastMcpAdapter } from './render.js';
+declare const adapter: FastMcpAdapter;
+/**
+ * Default export — singleton adapter instance resolved by the adapter loader.
+ *
+ * @example
+ * ```ts
+ * import adapter from '@skillit/target-fastmcp';
+ * await adapter.render(skill, ctx);
+ * ```
+ */
+export default adapter;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,YAAY,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,YAAY,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/C,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C,QAAA,MAAM,OAAO,gBAAuB,CAAC;AAErC;;;;;;;;GAQG;AACH,eAAe,OAAO,CAAC"}

package/dist/index.js

@@ -0,0 +1,27 @@
+/**
+ * `@skillit/target-fastmcp` — CLI-as-proxy invocation-target adapter.
+ *
+ * Resolved by `@skillit/mcp`'s adapter loader when target `cli:fastmcp` is
+ * requested. Emits SKILL.md output that routes tool calls through the
+ * Python `fastmcp` CLI, making the skill consumable by any agent with a
+ * shell tool (rather than only MCP-native harnesses).
+ *
+ * @packageDocumentation
+ */
+export { FastMcpAdapter } from './render.js';
+export { encodeFastMcpArgs } from './args.js';
+export { renderFastMcpSetup } from './setup.js';
+export { PACKAGE_VERSION } from './version.js';
+import { FastMcpAdapter } from './render.js';
+const adapter = new FastMcpAdapter();
+/**
+ * Default export — singleton adapter instance resolved by the adapter loader.
+ *
+ * @example
+ * ```ts
+ * import adapter from '@skillit/target-fastmcp';
+ * await adapter.render(skill, ctx);
+ * ```
+ */
+export default adapter;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEhD,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/C,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,OAAO,GAAG,IAAI,cAAc,EAAE,CAAC;AAErC;;;;;;;;GAQG;AACH,eAAe,OAAO,CAAC"}

package/dist/render.d.ts

@@ -0,0 +1,48 @@
+/**
+ * `FastMcpAdapter` — CLI-as-proxy invocation adapter for the Python `fastmcp` CLI.
+ *
+ * @remarks
+ * Emits SKILL.md output usable by any agent with a shell tool, by routing
+ * tool calls through `fastmcp` (https://gofastmcp.com). Unlike the
+ * `mcp-protocol` adapter, this adapter does NOT emit an `mcp:` frontmatter
+ * block — the MCP server connection is established via the shell
+ * `pyfastmcp connect` command described in the Setup section. Instead it
+ * emits a `generated-by:` block carrying the adapter's fingerprint
+ * (FR-IT-012).
+ *
+ * The body delegates to core's default render path with two extensions:
+ *
+ * 1. `bodyPrefix` — the Setup section is prepended to the SKILL.md body so
+ *    the consumer sees install/connect instructions before the standard
+ *    skill content.
+ * 2. `skipDefaultFunctionsRef` — the default `references/functions.md` is
+ *    suppressed; the adapter emits its own `references/tools.md` carrying
+ *    fastmcp command-shape rows produced by `renderCliParamTable`.
+ *
+ * Resources/prompts/types/etc. references are inherited from core
+ * unchanged — the only kind requiring CLI-specific rendering is functions
+ * (which become tools in the fastmcp dialect).
+ *
+ * @module render
+ */
+import type { AdapterFingerprint, AdapterRenderContext, ExtractedSkill, RenderedSkill } from '@skillit/core';
+import type { InvocationAdapter } from '@skillit/mcp';
+/**
+ * fastmcp CLI-as-proxy adapter — emits shell-command skills consumable by
+ * any agent with a `bash`/`shell` tool.
+ *
+ * @public
+ */
+export declare class FastMcpAdapter implements InvocationAdapter {
+    readonly target: "cli:fastmcp";
+    readonly fingerprint: AdapterFingerprint;
+    constructor();
+    /**
+     * Render an `ExtractedSkill` into a `RenderedSkill` carrying fastmcp
+     * command-shape SKILL.md output.
+     *
+     * The launch shape is selected by `resolveLaunchCommand` from `ctx.mode`.
+     */
+    render(skill: ExtractedSkill, ctx: AdapterRenderContext): Promise<RenderedSkill>;
+}
+//# sourceMappingURL=render.d.ts.map

package/dist/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,oBAAoB,EAEpB,cAAc,EAEd,aAAa,EACd,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,cAAc,CAAC;AAOrE;;;;;GAKG;AACH,qBAAa,cAAe,YAAW,iBAAiB;IACtD,QAAQ,CAAC,MAAM,EAAG,aAAa,CAAU;IACzC,QAAQ,CAAC,WAAW,EAAE,kBAAkB,CAAC;;IAUzC;;;;;OAKG;IACG,MAAM,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,EAAE,oBAAoB,GAAG,OAAO,CAAC,aAAa,CAAC;CAmCvF"}

package/dist/render.js

@@ -0,0 +1,149 @@
+/**
+ * `FastMcpAdapter` — CLI-as-proxy invocation adapter for the Python `fastmcp` CLI.
+ *
+ * @remarks
+ * Emits SKILL.md output usable by any agent with a shell tool, by routing
+ * tool calls through `fastmcp` (https://gofastmcp.com). Unlike the
+ * `mcp-protocol` adapter, this adapter does NOT emit an `mcp:` frontmatter
+ * block — the MCP server connection is established via the shell
+ * `pyfastmcp connect` command described in the Setup section. Instead it
+ * emits a `generated-by:` block carrying the adapter's fingerprint
+ * (FR-IT-012).
+ *
+ * The body delegates to core's default render path with two extensions:
+ *
+ * 1. `bodyPrefix` — the Setup section is prepended to the SKILL.md body so
+ *    the consumer sees install/connect instructions before the standard
+ *    skill content.
+ * 2. `skipDefaultFunctionsRef` — the default `references/functions.md` is
+ *    suppressed; the adapter emits its own `references/tools.md` carrying
+ *    fastmcp command-shape rows produced by `renderCliParamTable`.
+ *
+ * Resources/prompts/types/etc. references are inherited from core
+ * unchanged — the only kind requiring CLI-specific rendering is functions
+ * (which become tools in the fastmcp dialect).
+ *
+ * @module render
+ */
+import { estimateTokens, renderSkill, truncateToTokenBudget } from '@skillit/core';
+import { generatedByFrontmatter, splitToolsByNamespace } from '@skillit/mcp';
+import { renderToolsBody, resolveLaunchCommand } from '@skillit/mcp/adapter-utils';
+import { encodeFastMcpArgs } from './args.js';
+import { renderFastMcpSetup } from './setup.js';
+import { PACKAGE_VERSION } from './version.js';
+/**
+ * fastmcp CLI-as-proxy adapter — emits shell-command skills consumable by
+ * any agent with a `bash`/`shell` tool.
+ *
+ * @public
+ */
+export class FastMcpAdapter {
+    target = 'cli:fastmcp';
+    fingerprint;
+    constructor() {
+        this.fingerprint = {
+            adapter: '@skillit/target-fastmcp',
+            version: PACKAGE_VERSION,
+            targetCliRange: 'fastmcp@^2'
+        };
+    }
+    /**
+     * Render an `ExtractedSkill` into a `RenderedSkill` carrying fastmcp
+     * command-shape SKILL.md output.
+     *
+     * The launch shape is selected by `resolveLaunchCommand` from `ctx.mode`.
+     */
+    async render(skill, ctx) {
+        const launchCommand = resolveLaunchCommand(ctx);
+        // Frontmatter — `generated-by:` only. Do NOT emit `mcp:` block.
+        const additionalFrontmatter = generatedByFrontmatter(this.fingerprint);
+        // Setup section — install + connect commands + FR-IT-012 trace line.
+        const bodyPrefix = renderFastMcpSetup(ctx.skillName, launchCommand, this.fingerprint);
+        // Delegate body to core's default path. We disable:
+        //  - the default functions.md emission (we emit our own tools.md below)
+        //  - the inner canonicalize pass — because we mutate `references` after
+        //    this call, and a single canonicalize run at the host's outer wrapper
+        //    is sufficient (and avoids a redundant second pass on the body).
+        const baseRendered = renderSkill(skill, {
+            maxTokens: ctx.maxTokens,
+            additionalFrontmatter,
+            bodyPrefix,
+            skipDefaultFunctionsRef: true,
+            canonicalize: false,
+            invocation: undefined,
+            namePrefix: ctx.skillName
+        });
+        // Append our own tools.md (or per-namespace tools-<ns>.md split) if
+        // there are any tools. The host's outer canonicalize wrapper (in
+        // renderSkill's invocation-adapter dispatch) runs exactly once over
+        // this final shape, including the tools file(s).
+        const toolsRefs = renderToolsReference(skill.functions, ctx.skillName, ctx.maxTokens);
+        for (const ref of toolsRefs) {
+            baseRendered.references.push(ref);
+        }
+        return baseRendered;
+    }
+}
+/**
+ * Build the `references/tools.md` file(s) with fastmcp command-shape rows.
+ *
+ * Returns an empty array when the IR has no tools (so the adapter doesn't
+ * emit an empty file). When the rendered body fits inside `maxTokens`, a
+ * single `references/tools.md` is returned. Otherwise the helper splits
+ * the surface by first-segment namespace (FR-022) and returns one
+ * `references/tools-<ns>.md` per namespace. Each emitted file has its
+ * content passed through `truncateToTokenBudget` so even a single
+ * oversized namespace cannot blow past the budget; the `tokens` field
+ * reports the pre-truncation estimate, matching the convention used by
+ * core's renderer.
+ */
+function renderToolsReference(functions, skillName, maxTokens) {
+    if (functions.length === 0)
+        return [];
+    const cliVerb = `pyfastmcp call ${skillName}`;
+    const groups = splitToolsByNamespace(functions, (subset) => estimateTokens(renderToolsBody(subset, skillName, encodePlanForTable, encodeFastMcpArgs, cliVerb)), maxTokens);
+    const files = [];
+    for (const group of groups) {
+        const content = renderToolsBody(group.tools, skillName, encodePlanForTable, encodeFastMcpArgs, cliVerb);
+        const filename = group.name === 'tools'
+            ? `${skillName}/references/tools.md`
+            : `${skillName}/references/tools-${group.name}.md`;
+        files.push({
+            filename,
+            content: truncateToTokenBudget(content, maxTokens),
+            tokens: estimateTokens(content)
+        });
+    }
+    return files;
+}
+/**
+ * Encoder used by `renderCliParamTable`. Identical encoding rules to
+ * `encodeFastMcpArgs` but operates on a single plan so it can be the
+ * per-row-callback the table expects.
+ *
+ * fastmcp-specific: all flags use `=` (fastmcp parses RHS by schema), and
+ * Tier 3 fallback emits `--input-json '<JSON-payload>'`.
+ */
+function encodePlanForTable(plan) {
+    const key = plan.path.join('.');
+    switch (plan.type) {
+        case 'json':
+            return `--input-json '<JSON-payload>'`;
+        case 'scalar': {
+            if (plan.scalarType === 'boolean')
+                return `${key}=<true|false>`;
+            // string / number / integer
+            return `${key}=<value>`;
+        }
+        case 'enum':
+            // DU guarantees `plan.enum.length >= 1`.
+            return `${key}=<one-of-${plan.enum.join('|')}>`;
+        case 'string-array':
+            return `${key}=<comma-separated>`;
+        default: {
+            const _exhaustive = plan;
+            throw new Error(`encodePlanForTable: unhandled ParameterPlan arm: ${JSON.stringify(_exhaustive)}`);
+        }
+    }
+}
+//# sourceMappingURL=render.js.map

package/dist/render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.js","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAUH,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAEnF,OAAO,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAC7E,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACnF,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,OAAO,cAAc;IAChB,MAAM,GAAG,aAAsB,CAAC;IAChC,WAAW,CAAqB;IAEzC;QACE,IAAI,CAAC,WAAW,GAAG;YACjB,OAAO,EAAE,yBAAyB;YAClC,OAAO,EAAE,eAAe;YACxB,cAAc,EAAE,YAAY;SAC7B,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,MAAM,CAAC,KAAqB,EAAE,GAAyB;QAC3D,MAAM,aAAa,GAAG,oBAAoB,CAAC,GAAG,CAAC,CAAC;QAEhD,gEAAgE;QAChE,MAAM,qBAAqB,GAAG,sBAAsB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAEvE,qEAAqE;QACrE,MAAM,UAAU,GAAG,kBAAkB,CAAC,GAAG,CAAC,SAAS,EAAE,aAAa,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAEtF,oDAAoD;QACpD,wEAAwE;QACxE,wEAAwE;QACxE,0EAA0E;QAC1E,qEAAqE;QACrE,MAAM,YAAY,GAAG,WAAW,CAAC,KAAK,EAAE;YACtC,SAAS,EAAE,GAAG,CAAC,SAAS;YACxB,qBAAqB;YACrB,UAAU;YACV,uBAAuB,EAAE,IAAI;YAC7B,YAAY,EAAE,KAAK;YACnB,UAAU,EAAE,SAAS;YACrB,UAAU,EAAE,GAAG,CAAC,SAAS;SAC1B,CAAC,CAAC;QAEH,oEAAoE;QACpE,iEAAiE;QACjE,oEAAoE;QACpE,iDAAiD;QACjD,MAAM,SAAS,GAAG,oBAAoB,CAAC,KAAK,CAAC,SAAS,EAAE,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC;QACtF,KAAK,MAAM,GAAG,IAAI,SAAS,EAAE,CAAC;YAC5B,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACpC,CAAC;QAED,OAAO,YAAY,CAAC;IACtB,CAAC;CACF;AAED;;;;;;;;;;;;GAYG;AACH,SAAS,oBAAoB,CAC3B,SAAuC,EACvC,SAAiB,EACjB,SAAiB;IAEjB,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAEtC,MAAM,OAAO,GAAG,kBAAkB,SAAS,EAAE,CAAC;IAC9C,MAAM,MAAM,GAAG,qBAAqB,CAClC,SAAS,EACT,CAAC,MAAM,EAAE,EAAE,CACT,cAAc,CACZ,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,OAAO,CAAC,CACnF,EACH,SAAS,CACV,CAAC;IAEF,MAAM,KAAK,GAAmB,EAAE,CAAC;IACjC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,OAAO,GAAG,eAAe,CAC7B,KAAK,CAAC,KAAK,EACX,SAAS,EACT,kBAAkB,EAClB,iBAAiB,EACjB,OAAO,CACR,CAAC;QACF,MAAM,QAAQ,GACZ,KAAK,CAAC,IAAI,KAAK,OAAO;YACpB,CAAC,CAAC,GAAG,SAAS,sBAAsB;YACpC,CAAC,CAAC,GAAG,SAAS,qBAAqB,KAAK,CAAC,IAAI,KAAK,CAAC;QACvD,KAAK,CAAC,IAAI,CAAC;YACT,QAAQ;YACR,OAAO,EAAE,qBAAqB,CAAC,OAAO,EAAE,SAAS,CAAC;YAClD,MAAM,EAAE,cAAc,CAAC,OAAO,CAAC;SAChC,CAAC,CAAC;IACL,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,kBAAkB,CAAC,IAAmB;IAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAChC,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,MAAM;YACT,OAAO,+BAA+B,CAAC;QACzC,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS;gBAAE,OAAO,GAAG,GAAG,eAAe,CAAC;YAChE,4BAA4B;YAC5B,OAAO,GAAG,GAAG,UAAU,CAAC;QAC1B,CAAC;QACD,KAAK,MAAM;YACT,yCAAyC;YACzC,OAAO,GAAG,GAAG,YAAY,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;QAClD,KAAK,cAAc;YACjB,OAAO,GAAG,GAAG,oBAAoB,CAAC;QACpC,OAAO,CAAC,CAAC,CAAC;YACR,MAAM,WAAW,GAAU,IAAI,CAAC;YAChC,MAAM,IAAI,KAAK,CACb,oDAAoD,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,EAAE,CAClF,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/setup.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Setup-section renderer for the fastmcp CLI-as-proxy adapter.
+ *
+ * @remarks
+ * fastmcp (the Python `fastmcp` / `pyfastmcp` CLI, https://gofastmcp.com)
+ * lets non-MCP agents talk to MCP servers via shell commands. The Setup
+ * section embedded into SKILL.md tells the consumer:
+ *
+ * 1. How to install fastmcp (`pip install fastmcp`).
+ * 2. How to register the underlying MCP server (`pyfastmcp connect <name> -- ...`)
+ *    using the launch command we received from the host.
+ * 3. The adapter fingerprint (FR-IT-012) — a human-readable line so
+ *    freshness audits can detect drift between the rendered SKILL.md and
+ *    the adapter version that produced it.
+ *
+ * @module setup
+ */
+import type { AdapterFingerprint } from '@skillit/mcp';
+/**
+ * Stdio launch shape — mirrors the host's `AdapterRenderContext.launchCommand`.
+ */
+export interface StdioLaunchCommand {
+    readonly command: string;
+    readonly args?: readonly string[];
+    readonly env?: Readonly<Record<string, string>>;
+}
+/**
+ * HTTP endpoint shape — mirrors the host's `AdapterRenderContext.httpEndpoint`.
+ */
+export interface HttpLaunchEndpoint {
+    readonly url: string;
+    readonly headers?: Readonly<Record<string, string>>;
+}
+/**
+ * Render the Markdown Setup section for a fastmcp-proxied skill.
+ *
+ * @param skillName - kebab-case skill identifier; used as the fastmcp connection name
+ * @param launchCommand - stdio command (`{ command, args?, env? }`) or HTTP endpoint (`{ url, headers? }`)
+ * @param fingerprint - adapter fingerprint embedded in the FR-IT-012 trace line
+ * @returns Markdown string starting with `## Setup` and ending with the trace line
+ */
+export declare function renderFastMcpSetup(skillName: string, launchCommand: StdioLaunchCommand | HttpLaunchEndpoint, fingerprint: AdapterFingerprint): string;
+//# sourceMappingURL=setup.d.ts.map

package/dist/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../src/setup.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACjD;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACrD;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,kBAAkB,GAAG,kBAAkB,EACtD,WAAW,EAAE,kBAAkB,GAC9B,MAAM,CA0BR"}

package/dist/setup.js

@@ -0,0 +1,102 @@
+/**
+ * Setup-section renderer for the fastmcp CLI-as-proxy adapter.
+ *
+ * @remarks
+ * fastmcp (the Python `fastmcp` / `pyfastmcp` CLI, https://gofastmcp.com)
+ * lets non-MCP agents talk to MCP servers via shell commands. The Setup
+ * section embedded into SKILL.md tells the consumer:
+ *
+ * 1. How to install fastmcp (`pip install fastmcp`).
+ * 2. How to register the underlying MCP server (`pyfastmcp connect <name> -- ...`)
+ *    using the launch command we received from the host.
+ * 3. The adapter fingerprint (FR-IT-012) — a human-readable line so
+ *    freshness audits can detect drift between the rendered SKILL.md and
+ *    the adapter version that produced it.
+ *
+ * @module setup
+ */
+/**
+ * Render the Markdown Setup section for a fastmcp-proxied skill.
+ *
+ * @param skillName - kebab-case skill identifier; used as the fastmcp connection name
+ * @param launchCommand - stdio command (`{ command, args?, env? }`) or HTTP endpoint (`{ url, headers? }`)
+ * @param fingerprint - adapter fingerprint embedded in the FR-IT-012 trace line
+ * @returns Markdown string starting with `## Setup` and ending with the trace line
+ */
+export function renderFastMcpSetup(skillName, launchCommand, fingerprint) {
+    const lines = [];
+    lines.push('## Setup');
+    lines.push('');
+    lines.push('This skill proxies through `fastmcp`, the Python MCP CLI.');
+    lines.push('');
+    lines.push('### One-time install');
+    lines.push('');
+    lines.push('```sh');
+    lines.push('pip install fastmcp');
+    lines.push('```');
+    lines.push('');
+    lines.push(`### Connect to ${skillName}`);
+    lines.push('');
+    lines.push('```sh');
+    lines.push(renderConnectCommand(skillName, launchCommand));
+    lines.push('```');
+    lines.push('');
+    // FR-IT-012 trace line. The "fastmcp 2.x" marker corresponds to this
+    // adapter's `targetCliRange` (fastmcp@^2) — keep them in sync. The
+    // `via @skillit/target-fastmcp <version>` suffix matches the spec wording.
+    const cliMarker = formatCliMarker(fingerprint.targetCliRange);
+    lines.push(`> Generated for ${cliMarker} via ${fingerprint.adapter} ${fingerprint.version}`);
+    return lines.join('\n');
+}
+function renderConnectCommand(skillName, launchCommand) {
+    if ('url' in launchCommand) {
+        return `pyfastmcp connect ${shellQuote(skillName)} --url ${shellQuote(launchCommand.url)}`;
+    }
+    const argv = launchCommand.args && launchCommand.args.length > 0
+        ? ` ${launchCommand.args.map(shellQuote).join(' ')}`
+        : '';
+    return `pyfastmcp connect ${shellQuote(skillName)} -- ${shellQuote(launchCommand.command)}${argv}`;
+}
+/**
+ * Minimal POSIX shell quoting for tokens emitted into a copy/paste-ready
+ * Setup command. See target-mcpc's `setup.ts` for full rationale; the
+ * heuristic is identical (`safe charset` passthrough, single-quote with
+ * `'\''` escape otherwise).
+ */
+function shellQuote(token) {
+    if (token.length > 0 && /^[A-Za-z0-9_./@:=+-]+$/.test(token))
+        return token;
+    return `'${token.replace(/'/g, `'\\''`)}'`;
+}
+/**
+ * Format the targetCliRange (e.g. `fastmcp@^2`) into the marker form used in
+ * the human-readable fingerprint line ("fastmcp 2.x"). Falls back to a
+ * conservative "fastmcp" if the range is missing or unparseable so the
+ * fingerprint line remains stable.
+ */
+function formatCliMarker(targetCliRange) {
+    if (!targetCliRange)
+        return 'fastmcp';
+    // Match `<name>@<range>` where range starts with ^/~/= followed by a
+    // major version (with optional minor). Render as either "<name>
+    // <major>.<minor>.x" when both are present or "<name> <major>.x" when
+    // only major is provided.
+    const fullMatch = targetCliRange.match(/^([^@]+)@[\^~=]?(\d+)\.(\d+)/);
+    if (fullMatch) {
+        const [, name, major, minor] = fullMatch;
+        return `${name} ${major}.${minor}.x`;
+    }
+    const majorMatch = targetCliRange.match(/^([^@]+)@[\^~=]?(\d+)/);
+    if (majorMatch) {
+        const [, name, major] = majorMatch;
+        return `${name} ${major}.x`;
+    }
+    // Operators outside [\^~=] (e.g. `>=`, `<`) — strip the @range suffix and
+    // return just the package name so the fingerprint line stays human-readable.
+    // The fingerprint frontmatter still carries the precise raw range.
+    const nameOnly = targetCliRange.match(/^([^@]+)@/);
+    if (nameOnly)
+        return nameOnly[1];
+    return targetCliRange;
+}
+//# sourceMappingURL=setup.js.map

package/dist/setup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.js","sourceRoot":"","sources":["../src/setup.ts"],"names":[],"mappings":"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"}

package/dist/version.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Adapter package version — embedded into the `AdapterFingerprint`.
+ *
+ * @remarks
+ * Kept in a separate module so `render.ts` doesn't need to import the
+ * default export of `index.ts` (which would create a small circular import).
+ * Bump this string whenever the adapter's output shape changes.
+ */
+export declare const PACKAGE_VERSION = "0.1.0";
+//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,UAAU,CAAC"}

package/dist/version.js

@@ -0,0 +1,10 @@
+/**
+ * Adapter package version — embedded into the `AdapterFingerprint`.
+ *
+ * @remarks
+ * Kept in a separate module so `render.ts` doesn't need to import the
+ * default export of `index.ts` (which would create a small circular import).
+ * Bump this string whenever the adapter's output shape changes.
+ */
+export const PACKAGE_VERSION = '0.1.0';
+//# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,OAAO,CAAC"}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@skillit/target-fastmcp",
+  "version": "0.3.0",
+  "description": "FastMCP CLI-as-proxy invocation-target adapter for @skillit/mcp — emits shell-command skills using the fastmcp Python CLI for agents without MCP support",
+  "keywords": [
+    "agent-skills",
+    "ai",
+    "fastmcp",
+    "mcp",
+    "model-context-protocol",
+    "skillit"
+  ],
+  "license": "MIT",
+  "author": "Pradeep Mouli",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pradeepmouli/skillit.git",
+    "directory": "packages/target-fastmcp"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/pradeepmouli"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@skillit/core": "1.5.0",
+    "@skillit/mcp": "0.3.0"
+  },
+  "devDependencies": {
+    "@types/json-schema": "^7.0.15",
+    "@types/node": "^25.9.1",
+    "vitest": "^4.1.7",
+    "yaml": "^2.9.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}