@morsa/guidance-bank 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Morsa contributors
+
+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,135 @@
+# @morsa/guidance-bank
+
+`@morsa/guidance-bank` is a local tool for coding agents that stores persistent rules, skills, and reusable project guidance.
+
+It gives agents a stable guidance layer across sessions, projects, and tools.
+
+It gives you one durable place for reusable rules and skills across:
+
+- different agent providers
+- different projects
+- repeated sessions in the same project
+
+The goal is simple:
+
+- improve agent quality over time
+- reduce repeated prompting and repeated context reconstruction
+- save tokens by keeping stable guidance in a managed local guidance layer
+
+## Quick Start
+
+Install globally:
+
+```bash
+npm install -g @morsa/guidance-bank
+```
+
+Initialize once:
+
+```bash
+gbank init
+```
+
+That is the whole manual setup.
+
+After that, your agent can work with the AI Guidance Bank during normal coding sessions. When a project has no bank yet, the agent can detect that and guide creation as part of the workflow.
+
+## Why It Exists
+
+Agent guidance is usually fragmented.
+
+- Some rules live in `AGENTS.md`.
+- Some live in `.cursor`, `.claude`, or `.codex`.
+- Some are project-specific.
+- Some should be shared across many repositories.
+- Most provider-native flows are still weak at generating a good long-lived bank from real project evidence.
+
+`@morsa/guidance-bank` solves that by giving the agent one canonical local AI Guidance Bank it can use across providers and across projects.
+
+It is designed for two kinds of guidance:
+
+- cross-agent reusable guidance shared between projects
+- project-specific guidance derived from the actual codebase and stack
+
+## Supported Providers
+
+Current provider integrations:
+
+- Codex
+- Cursor
+- Claude Code
+
+## What Happens Next
+
+After `gbank init`, the normal flow is intentionally lightweight:
+
+1. You open a project in your agent.
+2. The agent resolves AI Guidance Bank context for that project.
+3. If a project bank does not exist yet, the agent can propose creating it.
+4. The agent can then keep using, improving, syncing, and editing the bank over time.
+
+In practice, the agent can:
+
+- create a project bank
+- review and improve an existing bank
+- sync an outdated bank layout
+- add or update rules
+- add or update skills
+- delete obsolete entries
+- read and inspect existing bank content
+
+The goal is that the agent handles the workflow, instead of you manually managing rule files all the time.
+
+## Why This Is Better Than Provider-Native Rules
+
+Provider-native repository guidance is useful, but usually limited.
+
+Common problems:
+
+- guidance is locked to one provider
+- project guidance is hard to reuse across repositories
+- generated rule sets often collapse into folder-structure summaries instead of real operational guidance
+- stack-specific guidance is usually shallow and repetitive
+
+`@morsa/guidance-bank` aims to build better project guidance by:
+
+- separating shared and project-specific guidance
+- deriving rules from real project evidence
+- carrying reusable rules across repositories
+- keeping one user-managed canonical layer that works with multiple agents
+
+## Stats
+
+Use `gbank stats` for a local overview of the AI Guidance Bank and recent activity:
+
+```bash
+gbank stats
+gbank stats --project /absolute/project/path
+gbank stats --json
+```
+
+It currently shows:
+
+- shared rule and skill counts
+- project bank counts and creation states
+- recent audit events
+- tool and provider activity breakdowns
+
+This is the first visibility layer; it will keep getting richer.
+
+## What We Plan To Improve
+
+Near-term product direction:
+
+- better visualization of rules and skills
+- richer stats, including token-oriented usage and cost insight
+- stronger project-bank management workflows
+- team and workspace-oriented memory sharing
+
+The long-term direction is not just “local rule files”, but a real guidance layer for agent work across projects, providers, and eventually teams.
+
+## Current Notes
+
+- `gbank init` requires an interactive terminal
+- at least one supported provider CLI must already be installed and available on `PATH`
+- the local AI Guidance Bank lives under `~/.guidance-bank`

package/bin/gbank.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import "../dist/cli/index.js";

package/dist/cli/commands/init.js

@@ -0,0 +1,27 @@
+import { InitService } from "../../core/init/initService.js";
+import { promptForProviders } from "../prompts/initPrompts.js";
+export const runInitCommand = async () => {
+    const selectedProviders = await promptForProviders();
+    const initService = new InitService();
+    const result = await initService.run({
+        selectedProviders,
+    });
+    const configuredProviders = result.integrations
+        .filter((integration) => integration.action === "installed" || integration.action === "reconfigured")
+        .map((integration) => integration.descriptor.displayName);
+    const reusedProviders = result.integrations
+        .filter((integration) => integration.action === "skipped")
+        .map((integration) => integration.descriptor.displayName);
+    console.info(result.alreadyExisted
+        ? `AI Guidance Bank is ready at ${result.bankRoot}.`
+        : `AI Guidance Bank initialized successfully at ${result.bankRoot}.`);
+    if (configuredProviders.length > 0) {
+        console.info(`Connected providers: ${configuredProviders.join(", ")}.`);
+    }
+    if (reusedProviders.length > 0) {
+        console.info(`Existing provider connections kept: ${reusedProviders.join(", ")}.`);
+    }
+    console.info("");
+    console.info("Next step:");
+    console.info("Open any project in your agent. The agent can use the AI Guidance Bank MCP to load durable rules and skills, detect when a project bank is missing, and guide you through creating or updating it.");
+};

package/dist/cli/commands/mcpServe.js

@@ -0,0 +1,8 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createMcpServer } from "../../mcp/createMcpServer.js";
+export const runMcpServeCommand = async () => {
+    const bankRoot = process.env.GUIDANCEBANK_ROOT;
+    const server = createMcpServer(bankRoot ? { bankRoot } : {});
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+};

package/dist/cli/commands/stats.js

@@ -0,0 +1,92 @@
+import { parseArgs } from "node:util";
+import { StatsService } from "../../core/stats/statsService.js";
+import { GuidanceBankCliError, UserInputError } from "../../shared/errors.js";
+const printStatsUsage = () => {
+    console.info("Usage: gbank stats [--project /absolute/project/path] [--json]");
+};
+const renderCountMap = (label, values) => {
+    const entries = Object.entries(values).sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0]));
+    if (entries.length === 0) {
+        return [`${label}: none`];
+    }
+    return [
+        `${label}:`,
+        ...entries.map(([key, count]) => `  - ${key}: ${count}`),
+    ];
+};
+const renderLatestEvents = (label, events) => {
+    if (events.length === 0) {
+        return [`${label}: none`];
+    }
+    return [
+        `${label}:`,
+        ...events.map((event) => `  - ${event.timestamp}  ${event.tool}  provider=${event.provider ?? "unknown"}  project=${event.projectId}  session=${event.sessionRef ?? "none"}`),
+    ];
+};
+const renderTextStats = (stats) => {
+    const lines = [
+        `AI Guidance Bank at ${stats.bankRoot}`,
+        "",
+        `Bank ID: ${stats.manifest.bankId}`,
+        `Storage version: ${stats.manifest.storageVersion}`,
+        `Providers: ${stats.manifest.enabledProviders.join(", ") || "none"}`,
+        `Transport: ${stats.manifest.defaultMcpTransport}`,
+        `Updated: ${stats.manifest.updatedAt}`,
+        "",
+        `Shared entries: rules=${stats.sharedEntries.rules}, skills=${stats.sharedEntries.skills}`,
+        `Project banks: ${stats.projects.total}`,
+        ...renderCountMap("Project creation states", stats.projects.byCreationState),
+        "",
+        `Audit events: ${stats.audit.totalEvents}`,
+        ...renderCountMap("Events by tool", stats.audit.byTool),
+        ...renderCountMap("Events by provider", stats.audit.byProvider),
+        ...renderLatestEvents("Latest events", stats.audit.latestEvents),
+    ];
+    if (!stats.project) {
+        return lines.join("\n");
+    }
+    lines.push("", `Project: ${stats.project.projectName}`, `Project ID: ${stats.project.projectId}`, `Project path: ${stats.project.projectPath}`, `Project state: ${stats.project.creationState}`, `Detected stacks: ${stats.project.detectedStacks.join(", ") || "none"}`, `Project entries: rules=${stats.project.entries.rules}, skills=${stats.project.entries.skills}`, `Project updated: ${stats.project.updatedAt}`, `Project audit events: ${stats.project.audit.totalEvents}`, ...renderCountMap("Project events by tool", stats.project.audit.byTool), ...renderCountMap("Project events by provider", stats.project.audit.byProvider), ...renderLatestEvents("Latest project events", stats.project.audit.latestEvents));
+    return lines.join("\n");
+};
+export const runStatsCommand = async (argv = process.argv.slice(2)) => {
+    const parsedArgs = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            help: {
+                type: "boolean",
+                short: "h",
+            },
+            project: {
+                type: "string",
+            },
+            json: {
+                type: "boolean",
+            },
+        },
+    });
+    if (parsedArgs.values.help) {
+        printStatsUsage();
+        return;
+    }
+    if (parsedArgs.positionals.length > 1 || (parsedArgs.positionals[0] && parsedArgs.positionals[0] !== "stats")) {
+        throw new UserInputError("Usage: gbank stats [--project /absolute/project/path] [--json]");
+    }
+    const statsService = new StatsService();
+    try {
+        const stats = await statsService.collect(parsedArgs.values.project
+            ? {
+                projectPath: parsedArgs.values.project,
+            }
+            : undefined);
+        if (parsedArgs.values.json) {
+            console.info(JSON.stringify(stats, null, 2));
+            return;
+        }
+        console.info(renderTextStats(stats));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown stats error.";
+        throw new GuidanceBankCliError(message);
+    }
+};

package/dist/cli/index.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { parseArgs } from "node:util";
+import { runInitCommand } from "./commands/init.js";
+import { runMcpServeCommand } from "./commands/mcpServe.js";
+import { runStatsCommand } from "./commands/stats.js";
+import { GuidanceBankCliError } from "../shared/errors.js";
+const require = createRequire(import.meta.url);
+const packageJson = require("../../package.json");
+const printUsage = () => {
+    console.info(`AI Guidance Bank
+
+Usage:
+  gbank init
+  gbank stats [--project /absolute/project/path] [--json]
+  gbank mcp serve
+
+Options:
+  -h, --help
+  -v, --version
+`);
+};
+const main = async () => {
+    const rawArgv = process.argv.slice(2);
+    const [rawCommand, rawSubcommand] = rawArgv;
+    if (rawCommand === "stats" && !["serve"].includes(rawSubcommand ?? "")) {
+        await runStatsCommand(rawArgv);
+        return;
+    }
+    const parsedArgs = parseArgs({
+        allowPositionals: true,
+        options: {
+            help: {
+                type: "boolean",
+                short: "h",
+            },
+            version: {
+                type: "boolean",
+                short: "v",
+            },
+        },
+    });
+    if (parsedArgs.values.help) {
+        printUsage();
+        return;
+    }
+    if (parsedArgs.values.version) {
+        console.info(packageJson.version);
+        return;
+    }
+    const [command, subcommand] = parsedArgs.positionals;
+    if (command === "init" && !subcommand) {
+        await runInitCommand();
+        return;
+    }
+    if (command === "mcp" && subcommand === "serve") {
+        await runMcpServeCommand();
+        return;
+    }
+    printUsage();
+    throw new GuidanceBankCliError("Unsupported command.");
+};
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(message);
+    process.exitCode = 1;
+});

package/dist/cli/postinstall.js

@@ -0,0 +1,24 @@
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { ensureMcpLauncher } from "../mcp/launcher.js";
+import { resolveDefaultBankRoot } from "../shared/paths.js";
+const hasInitializedBank = async (bankRoot) => {
+    try {
+        await access(path.join(bankRoot, "manifest.json"));
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const refreshDefaultMcpLauncherIfInitialized = async (options = {}) => {
+    const bankRoot = options.bankRoot ?? resolveDefaultBankRoot();
+    if (!(await hasInitializedBank(bankRoot))) {
+        return "skipped";
+    }
+    await ensureMcpLauncher(bankRoot);
+    return "updated";
+};
+export const runPostinstall = async () => {
+    await refreshDefaultMcpLauncherIfInitialized();
+};

package/dist/cli/prompts/initPrompts.js

@@ -0,0 +1,89 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { PROVIDER_DEFINITIONS } from "../../core/providers/providerRegistry.js";
+import { UserInputError } from "../../shared/errors.js";
+import { getProviderAvailability } from "./providerAvailability.js";
+const selectionSeparators = /[\s,]+/;
+const parseSelection = (value, availableProviders) => {
+    const trimmed = value.trim();
+    const availableProviderIds = new Set(availableProviders.filter((provider) => provider.available).map((provider) => provider.id));
+    if (!trimmed) {
+        const defaults = PROVIDER_DEFINITIONS.filter((provider) => availableProviderIds.has(provider.id)).map((provider) => provider.id);
+        if (defaults.length === 0) {
+            throw new UserInputError("No supported provider CLIs were found on PATH. Install at least one provider CLI first.");
+        }
+        return defaults;
+    }
+    const loweredValue = trimmed.toLowerCase();
+    if (loweredValue === "all" || loweredValue === "available") {
+        const defaults = PROVIDER_DEFINITIONS.filter((provider) => availableProviderIds.has(provider.id)).map((provider) => provider.id);
+        if (defaults.length === 0) {
+            throw new UserInputError("No supported provider CLIs were found on PATH. Install at least one provider CLI first.");
+        }
+        return defaults;
+    }
+    const selectedProviders = new Set();
+    const tokens = trimmed.split(selectionSeparators).filter(Boolean);
+    for (const token of tokens) {
+        const lowerToken = token.toLowerCase();
+        const numericIndex = Number.parseInt(lowerToken, 10);
+        const providerByIndex = Number.isInteger(numericIndex) && numericIndex >= 1 && numericIndex <= PROVIDER_DEFINITIONS.length
+            ? PROVIDER_DEFINITIONS[numericIndex - 1]
+            : undefined;
+        if (providerByIndex) {
+            if (!availableProviderIds.has(providerByIndex.id)) {
+                const unavailableProvider = availableProviders.find((provider) => provider.id === providerByIndex.id);
+                throw new UserInputError(unavailableProvider?.unavailableMessage ?? `${providerByIndex.displayName} is not available.`);
+            }
+            selectedProviders.add(providerByIndex.id);
+            continue;
+        }
+        const providerByName = PROVIDER_DEFINITIONS.find((provider) => {
+            const normalizedLabel = provider.displayName.toLowerCase().replaceAll(" ", "-");
+            return lowerToken === provider.id || lowerToken === normalizedLabel;
+        });
+        if (providerByName) {
+            if (!availableProviderIds.has(providerByName.id)) {
+                const unavailableProvider = availableProviders.find((provider) => provider.id === providerByName.id);
+                throw new UserInputError(unavailableProvider?.unavailableMessage ?? `${providerByName.displayName} is not available.`);
+            }
+            selectedProviders.add(providerByName.id);
+            continue;
+        }
+        throw new UserInputError(`Unsupported provider selection: ${token}`);
+    }
+    if (selectedProviders.size === 0) {
+        throw new UserInputError("You must select at least one provider.");
+    }
+    return [...selectedProviders];
+};
+export const promptForProviders = async () => {
+    if (!input.isTTY || !output.isTTY) {
+        throw new UserInputError("gbank init requires an interactive terminal in the current MVP.");
+    }
+    const availability = await getProviderAvailability();
+    output.write("Select providers to enable for AI Guidance Bank MCP:\n");
+    for (const [index, provider] of availability.entries()) {
+        output.write(`${index + 1}. ${provider.displayName} [${provider.available ? "available" : "not found"}]\n`);
+    }
+    output.write('Press Enter to select all available providers. Type numbers, ids, or "all".\n');
+    const readline = createInterface({ input, output });
+    try {
+        while (true) {
+            const answer = await readline.question("> ");
+            try {
+                return parseSelection(answer, availability);
+            }
+            catch (error) {
+                if (error instanceof UserInputError) {
+                    output.write(`${error.message}\n`);
+                    continue;
+                }
+                throw error;
+            }
+        }
+    }
+    finally {
+        readline.close();
+    }
+};

package/dist/cli/prompts/providerAvailability.js

@@ -0,0 +1,31 @@
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { delimiter } from "node:path";
+import { PROVIDER_DEFINITIONS } from "../../core/providers/providerRegistry.js";
+const isExecutableAvailable = async (command) => {
+    const pathValue = process.env.PATH;
+    if (!pathValue) {
+        return false;
+    }
+    for (const directoryPath of pathValue.split(delimiter)) {
+        if (!directoryPath) {
+            continue;
+        }
+        const executablePath = path.join(directoryPath, command);
+        try {
+            await access(executablePath);
+            return true;
+        }
+        catch {
+            continue;
+        }
+    }
+    return false;
+};
+export const getProviderAvailability = async () => Promise.all(PROVIDER_DEFINITIONS.map(async (provider) => ({
+    id: provider.id,
+    displayName: provider.displayName,
+    cliCommand: provider.cliCommand,
+    available: provider.isAvailable ? await provider.isAvailable() : await isExecutableAvailable(provider.cliCommand),
+    unavailableMessage: provider.unavailableMessage,
+})));

package/dist/core/audit/summarizeEntryContent.js

@@ -0,0 +1,43 @@
+import { createHash } from "node:crypto";
+import { parseCanonicalRuleDocument, parseCanonicalSkillDocument } from "../bank/canonicalEntry.js";
+const countLines = (content) => (content.length === 0 ? 0 : content.split(/\r?\n/u).length);
+export const summarizeEntryContent = (kind, content) => {
+    if (content === null) {
+        return {
+            exists: false,
+            sha256: null,
+            charCount: 0,
+            lineCount: 0,
+            entryId: null,
+            title: null,
+            entryKind: null,
+            stacks: [],
+            topics: [],
+        };
+    }
+    const baseSummary = {
+        exists: true,
+        sha256: createHash("sha256").update(content, "utf8").digest("hex"),
+        charCount: content.length,
+        lineCount: countLines(content),
+        entryId: null,
+        title: null,
+        entryKind: null,
+        stacks: [],
+        topics: [],
+    };
+    try {
+        const document = kind === "rules" ? parseCanonicalRuleDocument(content) : parseCanonicalSkillDocument(content);
+        return {
+            ...baseSummary,
+            entryId: document.frontmatter.id,
+            title: document.frontmatter.title,
+            entryKind: document.frontmatter.kind,
+            stacks: [...document.frontmatter.stacks],
+            topics: [...document.frontmatter.topics],
+        };
+    }
+    catch {
+        return baseSummary;
+    }
+};

package/dist/core/audit/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/bank/canonicalEntry.js

@@ -0,0 +1,106 @@
+import { z } from "zod";
+import { DETECTABLE_STACKS } from "../context/types.js";
+const DetectableStackSchema = z.enum(DETECTABLE_STACKS);
+const RuleFrontmatterSchema = z
+    .object({
+    id: z.string().trim().min(1),
+    kind: z.literal("rule"),
+    title: z.string().trim().min(1),
+    stacks: z.array(DetectableStackSchema).default([]),
+    topics: z.array(z.string().trim().min(1)).default([]),
+})
+    .strict();
+const SkillFrontmatterSchema = z
+    .object({
+    id: z.string().trim().min(1),
+    kind: z.literal("skill"),
+    title: z.string().trim().min(1),
+    name: z.string().trim().min(1).optional(),
+    description: z.string().trim().min(1),
+    stacks: z.array(DetectableStackSchema).default([]),
+    topics: z.array(z.string().trim().min(1)).default([]),
+})
+    .strict();
+const FRONTMATTER_PATTERN = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/u;
+const parseScalarValue = (rawValue) => {
+    const trimmedValue = rawValue.trim();
+    if (trimmedValue.startsWith("[") && trimmedValue.endsWith("]")) {
+        const innerValue = trimmedValue.slice(1, -1).trim();
+        if (innerValue.length === 0) {
+            return [];
+        }
+        return innerValue.split(",").map((item) => item.trim().replace(/^['"]|['"]$/gu, ""));
+    }
+    return trimmedValue.replace(/^['"]|['"]$/gu, "");
+};
+const parseFrontmatterBlock = (content) => {
+    const match = content.match(FRONTMATTER_PATTERN);
+    if (!match) {
+        return null;
+    }
+    const rawFrontmatter = match[1] ?? "";
+    const body = match[2]?.trim() ?? "";
+    const frontmatter = {};
+    for (const line of rawFrontmatter.split(/\r?\n/u)) {
+        const trimmedLine = line.trim();
+        if (trimmedLine.length === 0 || trimmedLine.startsWith("#")) {
+            continue;
+        }
+        const separatorIndex = trimmedLine.indexOf(":");
+        if (separatorIndex <= 0) {
+            throw new Error(`Invalid frontmatter line: ${trimmedLine}`);
+        }
+        const key = trimmedLine.slice(0, separatorIndex).trim();
+        const rawValue = trimmedLine.slice(separatorIndex + 1);
+        frontmatter[key] = parseScalarValue(rawValue);
+    }
+    return {
+        frontmatter,
+        body,
+    };
+};
+const assertBody = (body) => {
+    const trimmedBody = body.trim();
+    if (trimmedBody.length === 0) {
+        throw new Error("Canonical entry body must not be empty.");
+    }
+    return trimmedBody;
+};
+export const parseCanonicalRuleDocument = (content) => {
+    const parsedContent = parseFrontmatterBlock(content);
+    if (!parsedContent) {
+        throw new Error("Canonical rule files must start with a frontmatter block.");
+    }
+    const frontmatter = RuleFrontmatterSchema.parse(parsedContent.frontmatter);
+    return {
+        frontmatter,
+        body: assertBody(parsedContent.body),
+    };
+};
+export const parseCanonicalSkillDocument = (content) => {
+    const parsedContent = parseFrontmatterBlock(content);
+    if (!parsedContent) {
+        throw new Error("Canonical skill files must start with a frontmatter block.");
+    }
+    const frontmatter = SkillFrontmatterSchema.parse(parsedContent.frontmatter);
+    return {
+        frontmatter,
+        body: assertBody(parsedContent.body),
+    };
+};
+export const serializeCanonicalRuleFrontmatter = (frontmatter) => `---
+id: ${frontmatter.id}
+kind: rule
+title: ${frontmatter.title}
+stacks: [${frontmatter.stacks.join(", ")}]
+topics: [${frontmatter.topics.join(", ")}]
+---`;
+export const serializeCanonicalSkillFrontmatter = (frontmatter) => `---
+id: ${frontmatter.id}
+kind: skill
+title: ${frontmatter.title}
+${frontmatter.name ? `name: ${frontmatter.name}
+` : ""}description: ${frontmatter.description}
+stacks: [${frontmatter.stacks.join(", ")}]
+topics: [${frontmatter.topics.join(", ")}]
+---`;

package/dist/core/bank/integration.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { McpServerConfigSchema } from "../../mcp/config.js";
+import { PROVIDER_IDS } from "./types.js";
+export const ProviderIntegrationDescriptorSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    provider: z.enum(PROVIDER_IDS),
+    displayName: z.string().min(1),
+    serverName: z.string().min(1),
+    installationMethod: z.enum(["provider-cli", "config-file"]),
+    scope: z.literal("user"),
+    mcpServer: McpServerConfigSchema,
+    instructions: z.array(z.string()),
+})
+    .strict();
+export const parseProviderIntegrationDescriptor = (value) => ProviderIntegrationDescriptorSchema.parse(value);