midnight-mcp 0.1.1 → 0.1.2

package/dist/resources/index.d.ts

@@ -1,6 +1,6 @@
 export { documentationResources, getDocumentation, listDocumentationResources, } from "./docs.js";
-export { codeResources, getCode, listCodeResources, } from "./code.js";
-export { schemaResources, getSchema, listSchemaResources, } from "./schemas.js";
-export type { ResourceDefinition } from "./docs.js";
-export declare const allResources: import("./docs.js").ResourceDefinition[];
+export { codeResources, getCode, listCodeResources } from "./code.js";
+export { schemaResources, getSchema, listSchemaResources } from "./schemas.js";
+export type { ResourceDefinition } from "./schemas.js";
+export declare const allResources: import("./schemas.js").ResourceDefinition[];
 //# sourceMappingURL=index.d.ts.map

package/dist/resources/index.js

@@ -1,6 +1,6 @@
 export { documentationResources, getDocumentation, listDocumentationResources, } from "./docs.js";
-export { codeResources, getCode, listCodeResources, } from "./code.js";
-export { schemaResources, getSchema, listSchemaResources, } from "./schemas.js";
+export { codeResources, getCode, listCodeResources } from "./code.js";
+export { schemaResources, getSchema, listSchemaResources } from "./schemas.js";
 // Combine all resources
 import { documentationResources } from "./docs.js";
 import { codeResources } from "./code.js";

package/dist/tools/repository/constants.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Repository constants
+ * Aliases, example definitions, and configuration data
+ */
+export declare const REPO_ALIASES: Record<string, {
+    owner: string;
+    repo: string;
+}>;
+export interface ExampleDefinition {
+    name: string;
+    repository: string;
+    description: string;
+    category: string;
+    complexity: "beginner" | "intermediate" | "advanced";
+    mainFile: string;
+    features: string[];
+}
+export declare const EXAMPLES: ExampleDefinition[];
+//# sourceMappingURL=constants.d.ts.map

package/dist/tools/repository/constants.js

@@ -0,0 +1,103 @@
+/**
+ * Repository constants
+ * Aliases, example definitions, and configuration data
+ */
+// Repository name mapping
+export const REPO_ALIASES = {
+    // Core Language & SDK
+    compact: { owner: "midnightntwrk", repo: "compact" },
+    "midnight-js": { owner: "midnightntwrk", repo: "midnight-js" },
+    js: { owner: "midnightntwrk", repo: "midnight-js" },
+    sdk: { owner: "midnightntwrk", repo: "midnight-js" },
+    // Documentation
+    docs: { owner: "midnightntwrk", repo: "midnight-docs" },
+    "midnight-docs": { owner: "midnightntwrk", repo: "midnight-docs" },
+    // Example DApps
+    "example-counter": { owner: "midnightntwrk", repo: "example-counter" },
+    counter: { owner: "midnightntwrk", repo: "example-counter" },
+    "example-bboard": { owner: "midnightntwrk", repo: "example-bboard" },
+    bboard: { owner: "midnightntwrk", repo: "example-bboard" },
+    "example-dex": { owner: "midnightntwrk", repo: "example-dex" },
+    dex: { owner: "midnightntwrk", repo: "example-dex" },
+    // Developer Tools
+    "create-mn-app": { owner: "midnightntwrk", repo: "create-mn-app" },
+    "midnight-wallet": { owner: "midnightntwrk", repo: "midnight-wallet" },
+    wallet: { owner: "midnightntwrk", repo: "midnight-wallet" },
+    // Infrastructure
+    "midnight-indexer": { owner: "midnightntwrk", repo: "midnight-indexer" },
+    indexer: { owner: "midnightntwrk", repo: "midnight-indexer" },
+    "midnight-node-docker": {
+        owner: "midnightntwrk",
+        repo: "midnight-node-docker",
+    },
+    node: { owner: "midnightntwrk", repo: "midnight-node-docker" },
+    // APIs & Connectors
+    "midnight-dapp-connector-api": {
+        owner: "midnightntwrk",
+        repo: "midnight-dapp-connector-api",
+    },
+    connector: { owner: "midnightntwrk", repo: "midnight-dapp-connector-api" },
+    // Tooling
+    "compact-tree-sitter": {
+        owner: "midnightntwrk",
+        repo: "compact-tree-sitter",
+    },
+    // Community
+    "midnight-awesome-dapps": {
+        owner: "midnightntwrk",
+        repo: "midnight-awesome-dapps",
+    },
+    awesome: { owner: "midnightntwrk", repo: "midnight-awesome-dapps" },
+    "contributor-hub": { owner: "midnightntwrk", repo: "contributor-hub" },
+    // Partner Libraries (OpenZeppelin)
+    "compact-contracts": { owner: "OpenZeppelin", repo: "compact-contracts" },
+    openzeppelin: { owner: "OpenZeppelin", repo: "compact-contracts" },
+    oz: { owner: "OpenZeppelin", repo: "compact-contracts" },
+};
+export const EXAMPLES = [
+    {
+        name: "Counter",
+        repository: "midnightntwrk/example-counter",
+        description: "Simple counter contract demonstrating basic Compact concepts. Perfect for learning ledger state, circuits, and witnesses.",
+        category: "counter",
+        complexity: "beginner",
+        mainFile: "contract/src/counter.compact",
+        features: [
+            "Ledger state management",
+            "Basic circuit definition",
+            "Counter increment/decrement",
+            "TypeScript integration",
+        ],
+    },
+    {
+        name: "Bulletin Board",
+        repository: "midnightntwrk/example-bboard",
+        description: "Full DApp example with CLI and React UI. Demonstrates posting messages with privacy features.",
+        category: "bboard",
+        complexity: "intermediate",
+        mainFile: "contract/src/bboard.compact",
+        features: [
+            "Private messaging",
+            "React frontend",
+            "CLI interface",
+            "Wallet integration",
+            "Disclose operations",
+        ],
+    },
+    {
+        name: "DEX (Decentralized Exchange)",
+        repository: "midnightntwrk/example-dex",
+        description: "Advanced DApp example showing token swaps and liquidity pools with privacy-preserving transactions.",
+        category: "dex",
+        complexity: "advanced",
+        mainFile: "contract/src/dex.compact",
+        features: [
+            "Token swaps",
+            "Liquidity pools",
+            "Privacy-preserving trades",
+            "Price calculations",
+            "Advanced state management",
+        ],
+    },
+];
+//# sourceMappingURL=constants.js.map

package/dist/tools/repository/handlers.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Repository handler functions
+ * Business logic for repository-related MCP tools
+ */
+import type { GetFileInput, ListExamplesInput, GetLatestUpdatesInput, GetVersionInfoInput, CheckBreakingChangesInput, GetMigrationGuideInput, GetFileAtVersionInput, CompareSyntaxInput, GetLatestSyntaxInput } from "./schemas.js";
+/**
+ * Resolve repository name alias to owner/repo
+ */
+export declare function resolveRepo(repoName?: string): {
+    owner: string;
+    repo: string;
+} | null;
+/**
+ * Retrieve a specific file from Midnight repositories
+ */
+export declare function getFile(input: GetFileInput): Promise<{
+    error: string;
+    suggestion: string;
+    repository?: undefined;
+    content?: undefined;
+    path?: undefined;
+    sha?: undefined;
+    size?: undefined;
+    url?: undefined;
+} | {
+    error: string;
+    repository: string;
+    suggestion: string;
+    content?: undefined;
+    path?: undefined;
+    sha?: undefined;
+    size?: undefined;
+    url?: undefined;
+} | {
+    content: string;
+    path: string;
+    repository: string;
+    sha: string;
+    size: number;
+    url: string;
+    error?: undefined;
+    suggestion?: undefined;
+}>;
+/**
+ * List available example contracts and DApps
+ */
+export declare function listExamples(input: ListExamplesInput): Promise<{
+    examples: {
+        name: string;
+        repository: string;
+        description: string;
+        complexity: "beginner" | "intermediate" | "advanced";
+        mainFile: string;
+        features: string[];
+        githubUrl: string;
+    }[];
+    totalCount: number;
+    categories: string[];
+}>;
+/**
+ * Retrieve recent changes across Midnight repositories
+ */
+export declare function getLatestUpdates(input: GetLatestUpdatesInput): Promise<{
+    summary: {
+        since: string;
+        totalCommits: number;
+        activeRepositories: number;
+        checkedRepositories: number;
+    };
+    updates: {
+        repository: string;
+        commitCount: number;
+        latestCommit: {
+            message: string;
+            date: string;
+            author: string;
+            url: string;
+        } | null;
+        recentCommits: {
+            message: string;
+            date: string;
+            sha: string;
+        }[];
+    }[];
+}>;
+/**
+ * Get version and release info for a repository
+ */
+export declare function getVersionInfo(input: GetVersionInfoInput): Promise<{
+    repository: string;
+    latestVersion: string;
+    latestStableVersion: string;
+    publishedAt: string | null;
+    releaseNotes: string | null;
+    recentReleases: {
+        version: string;
+        date: string;
+        isPrerelease: boolean;
+        url: string;
+    }[];
+    recentBreakingChanges: string[];
+    versionContext: string;
+}>;
+/**
+ * Check for breaking changes since a specific version
+ */
+export declare function checkBreakingChanges(input: CheckBreakingChangesInput): Promise<{
+    repository: string;
+    currentVersion: string;
+    latestVersion: string | null;
+    isOutdated: boolean;
+    versionsBehind: number;
+    hasBreakingChanges: boolean;
+    breakingChanges: string[];
+    recommendation: string;
+}>;
+/**
+ * Get migration guide between versions
+ */
+export declare function getMigrationGuide(input: GetMigrationGuideInput): Promise<{
+    repository: string;
+    from: string;
+    to: string;
+    summary: {
+        breakingChangesCount: number;
+        deprecationsCount: number;
+        newFeaturesCount: number;
+    };
+    breakingChanges: string[];
+    deprecations: string[];
+    newFeatures: string[];
+    migrationSteps: string[];
+    migrationDifficulty: string;
+}>;
+/**
+ * Get a file at a specific version - critical for version-accurate recommendations
+ */
+export declare function getFileAtVersion(input: GetFileAtVersionInput): Promise<{
+    repository: string;
+    path: string;
+    version: string;
+    content: string;
+    note: string;
+}>;
+/**
+ * Compare syntax between two versions - shows what changed
+ */
+export declare function compareSyntax(input: CompareSyntaxInput): Promise<{
+    repository: string;
+    path: string;
+    oldVersion: string;
+    newVersion: string;
+    hasDifferences: boolean;
+    oldContent: string | null;
+    newContent: string | null;
+    recommendation: string;
+}>;
+/**
+ * Get the latest syntax reference for Compact language
+ * This is the source of truth for writing valid, compilable contracts
+ */
+export declare function getLatestSyntax(input: GetLatestSyntaxInput): Promise<{
+    repository: string;
+    version: string;
+    warning: string;
+    syntaxFiles: never[];
+    examplePaths: string[];
+    note?: undefined;
+} | {
+    repository: string;
+    version: string;
+    syntaxFiles: {
+        path: string;
+        content: string;
+    }[];
+    note: string;
+    warning?: undefined;
+    examplePaths?: undefined;
+}>;
+//# sourceMappingURL=handlers.d.ts.map

package/dist/tools/repository/handlers.js

@@ -0,0 +1,311 @@
+/**
+ * Repository handler functions
+ * Business logic for repository-related MCP tools
+ */
+import { githubClient } from "../../pipeline/index.js";
+import { releaseTracker } from "../../pipeline/releases.js";
+import { logger, DEFAULT_REPOSITORIES } from "../../utils/index.js";
+import { REPO_ALIASES, EXAMPLES } from "./constants.js";
+/**
+ * Resolve repository name alias to owner/repo
+ */
+export function resolveRepo(repoName) {
+    // Default to compact if not provided
+    const name = repoName || "compact";
+    const normalized = name.toLowerCase().replace(/^midnightntwrk\//, "");
+    const alias = REPO_ALIASES[normalized];
+    if (alias)
+        return alias;
+    // Try to find in configured repos
+    for (const config of DEFAULT_REPOSITORIES) {
+        if (config.repo.toLowerCase() === normalized) {
+            return { owner: config.owner, repo: config.repo };
+        }
+    }
+    // Assume it's a full org/repo name
+    if (name.includes("/")) {
+        const [owner, repo] = name.split("/");
+        return { owner, repo };
+    }
+    return null;
+}
+/**
+ * Retrieve a specific file from Midnight repositories
+ */
+export async function getFile(input) {
+    logger.debug("Getting file", { repo: input.repo, path: input.path });
+    const repoInfo = resolveRepo(input.repo);
+    if (!repoInfo) {
+        return {
+            error: `Unknown repository: ${input.repo}`,
+            suggestion: `Valid repositories: ${Object.keys(REPO_ALIASES).join(", ")}`,
+        };
+    }
+    const file = await githubClient.getFileContent(repoInfo.owner, repoInfo.repo, input.path, input.ref);
+    if (!file) {
+        return {
+            error: `File not found: ${input.path}`,
+            repository: `${repoInfo.owner}/${repoInfo.repo}`,
+            suggestion: "Check the file path and try again. Use midnight:list-examples to see available example files.",
+        };
+    }
+    return {
+        content: file.content,
+        path: file.path,
+        repository: `${repoInfo.owner}/${repoInfo.repo}`,
+        sha: file.sha,
+        size: file.size,
+        url: `https://github.com/${repoInfo.owner}/${repoInfo.repo}/blob/${input.ref || "main"}/${file.path}`,
+    };
+}
+/**
+ * List available example contracts and DApps
+ */
+export async function listExamples(input) {
+    logger.debug("Listing examples", { category: input.category });
+    let filteredExamples = EXAMPLES;
+    if (input.category && input.category !== "all") {
+        filteredExamples = EXAMPLES.filter((e) => e.category === input.category);
+    }
+    return {
+        examples: filteredExamples.map((e) => ({
+            name: e.name,
+            repository: e.repository,
+            description: e.description,
+            complexity: e.complexity,
+            mainFile: e.mainFile,
+            features: e.features,
+            githubUrl: `https://github.com/${e.repository}`,
+        })),
+        totalCount: filteredExamples.length,
+        categories: [...new Set(EXAMPLES.map((e) => e.category))],
+    };
+}
+/**
+ * Retrieve recent changes across Midnight repositories
+ */
+export async function getLatestUpdates(input) {
+    logger.debug("Getting latest updates", input);
+    // Default to last 7 days
+    const since = input.since || new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+    const repos = input.repos?.map(resolveRepo).filter(Boolean) ||
+        DEFAULT_REPOSITORIES.map((r) => ({ owner: r.owner, repo: r.repo }));
+    const updates = [];
+    for (const repo of repos) {
+        if (!repo)
+            continue;
+        const commits = await githubClient.getRecentCommits(repo.owner, repo.repo, since, 10);
+        if (commits.length > 0) {
+            updates.push({
+                repository: `${repo.owner}/${repo.repo}`,
+                commits,
+            });
+        }
+    }
+    // Sort by most recent commit
+    updates.sort((a, b) => {
+        const aDate = a.commits[0]?.date || "";
+        const bDate = b.commits[0]?.date || "";
+        return bDate.localeCompare(aDate);
+    });
+    // Generate summary
+    const totalCommits = updates.reduce((sum, u) => sum + u.commits.length, 0);
+    const activeRepos = updates.filter((u) => u.commits.length > 0).length;
+    return {
+        summary: {
+            since,
+            totalCommits,
+            activeRepositories: activeRepos,
+            checkedRepositories: repos.length,
+        },
+        updates: updates.map((u) => ({
+            repository: u.repository,
+            commitCount: u.commits.length,
+            latestCommit: u.commits[0]
+                ? {
+                    message: u.commits[0].message.split("\n")[0], // First line only
+                    date: u.commits[0].date,
+                    author: u.commits[0].author,
+                    url: u.commits[0].url,
+                }
+                : null,
+            recentCommits: u.commits.slice(0, 5).map((c) => ({
+                message: c.message.split("\n")[0],
+                date: c.date,
+                sha: c.sha.substring(0, 7),
+            })),
+        })),
+    };
+}
+/**
+ * Get version and release info for a repository
+ */
+export async function getVersionInfo(input) {
+    logger.debug("Getting version info", input);
+    const resolved = resolveRepo(input.repo);
+    if (!resolved) {
+        throw new Error(`Unknown repository: ${input.repo}. Available: ${Object.keys(REPO_ALIASES).join(", ")}`);
+    }
+    const versionInfo = await releaseTracker.getVersionInfo(resolved.owner, resolved.repo);
+    return {
+        repository: `${resolved.owner}/${resolved.repo}`,
+        latestVersion: versionInfo.latestRelease?.tag || "No releases found",
+        latestStableVersion: versionInfo.latestStableRelease?.tag || "No stable releases",
+        publishedAt: versionInfo.latestRelease?.publishedAt || null,
+        releaseNotes: versionInfo.latestRelease?.body || null,
+        recentReleases: versionInfo.recentReleases.slice(0, 5).map((r) => ({
+            version: r.tag,
+            date: r.publishedAt.split("T")[0],
+            isPrerelease: r.isPrerelease,
+            url: r.url,
+        })),
+        recentBreakingChanges: versionInfo.changelog
+            .slice(0, 3)
+            .flatMap((c) => c.changes.breaking)
+            .slice(0, 10),
+        versionContext: releaseTracker.getVersionContext(versionInfo),
+    };
+}
+/**
+ * Check for breaking changes since a specific version
+ */
+export async function checkBreakingChanges(input) {
+    logger.debug("Checking breaking changes", input);
+    const resolved = resolveRepo(input.repo);
+    if (!resolved) {
+        throw new Error(`Unknown repository: ${input.repo}. Available: ${Object.keys(REPO_ALIASES).join(", ")}`);
+    }
+    const outdatedInfo = await releaseTracker.isOutdated(resolved.owner, resolved.repo, input.currentVersion);
+    const breakingChanges = await releaseTracker.getBreakingChangesSince(resolved.owner, resolved.repo, input.currentVersion);
+    return {
+        repository: `${resolved.owner}/${resolved.repo}`,
+        currentVersion: input.currentVersion,
+        latestVersion: outdatedInfo.latestVersion,
+        isOutdated: outdatedInfo.isOutdated,
+        versionsBehind: outdatedInfo.versionsBehind,
+        hasBreakingChanges: outdatedInfo.hasBreakingChanges,
+        breakingChanges: breakingChanges,
+        recommendation: outdatedInfo.hasBreakingChanges
+            ? `⚠️ Breaking changes detected! Review the ${breakingChanges.length} breaking change(s) before upgrading.`
+            : outdatedInfo.isOutdated
+                ? `✅ Safe to upgrade. No breaking changes detected since ${input.currentVersion}.`
+                : `✅ You're on the latest version.`,
+    };
+}
+/**
+ * Get migration guide between versions
+ */
+export async function getMigrationGuide(input) {
+    logger.debug("Getting migration guide", input);
+    const resolved = resolveRepo(input.repo);
+    if (!resolved) {
+        throw new Error(`Unknown repository: ${input.repo}. Available: ${Object.keys(REPO_ALIASES).join(", ")}`);
+    }
+    const guide = await releaseTracker.getMigrationGuide(resolved.owner, resolved.repo, input.fromVersion, input.toVersion);
+    return {
+        repository: `${resolved.owner}/${resolved.repo}`,
+        from: guide.from,
+        to: guide.to,
+        summary: {
+            breakingChangesCount: guide.breakingChanges.length,
+            deprecationsCount: guide.deprecations.length,
+            newFeaturesCount: guide.newFeatures.length,
+        },
+        breakingChanges: guide.breakingChanges,
+        deprecations: guide.deprecations,
+        newFeatures: guide.newFeatures,
+        migrationSteps: guide.migrationSteps,
+        migrationDifficulty: guide.breakingChanges.length === 0
+            ? "Easy - No breaking changes"
+            : guide.breakingChanges.length <= 3
+                ? "Moderate - Few breaking changes"
+                : "Complex - Multiple breaking changes, plan carefully",
+    };
+}
+/**
+ * Get a file at a specific version - critical for version-accurate recommendations
+ */
+export async function getFileAtVersion(input) {
+    logger.debug("Getting file at version", input);
+    const resolved = resolveRepo(input.repo);
+    if (!resolved) {
+        throw new Error(`Unknown repository: ${input.repo}. Available: ${Object.keys(REPO_ALIASES).join(", ")}`);
+    }
+    const result = await releaseTracker.getFileAtVersion(resolved.owner, resolved.repo, input.path, input.version);
+    if (!result) {
+        throw new Error(`File not found: ${input.path} at version ${input.version} in ${input.repo}`);
+    }
+    return {
+        repository: `${resolved.owner}/${resolved.repo}`,
+        path: input.path,
+        version: result.version,
+        content: result.content,
+        note: `This is the exact content at version ${result.version}. Use this as the source of truth for syntax and API at this version.`,
+    };
+}
+/**
+ * Compare syntax between two versions - shows what changed
+ */
+export async function compareSyntax(input) {
+    logger.debug("Comparing syntax between versions", input);
+    const resolved = resolveRepo(input.repo);
+    if (!resolved) {
+        throw new Error(`Unknown repository: ${input.repo}. Available: ${Object.keys(REPO_ALIASES).join(", ")}`);
+    }
+    // If no newVersion specified, get latest
+    let newVersion = input.newVersion;
+    if (!newVersion) {
+        const versionInfo = await releaseTracker.getVersionInfo(resolved.owner, resolved.repo);
+        newVersion =
+            versionInfo.latestStableRelease?.tag ||
+                versionInfo.latestRelease?.tag ||
+                "main";
+    }
+    const comparison = await releaseTracker.compareSyntax(resolved.owner, resolved.repo, input.path, input.oldVersion, newVersion);
+    return {
+        repository: `${resolved.owner}/${resolved.repo}`,
+        path: input.path,
+        oldVersion: comparison.oldVersion,
+        newVersion: comparison.newVersion,
+        hasDifferences: comparison.hasDifferences,
+        oldContent: comparison.oldContent,
+        newContent: comparison.newContent,
+        recommendation: comparison.hasDifferences
+            ? `⚠️ This file has changed between ${comparison.oldVersion} and ${comparison.newVersion}. Review the differences before using code patterns from the old version.`
+            : `✅ No changes in this file between versions.`,
+    };
+}
+/**
+ * Get the latest syntax reference for Compact language
+ * This is the source of truth for writing valid, compilable contracts
+ */
+export async function getLatestSyntax(input) {
+    logger.debug("Getting latest syntax reference", input);
+    const resolved = resolveRepo(input.repo);
+    if (!resolved) {
+        throw new Error(`Unknown repository: ${input.repo}. Available: ${Object.keys(REPO_ALIASES).join(", ")}`);
+    }
+    const reference = await releaseTracker.getLatestSyntaxReference(resolved.owner, resolved.repo);
+    if (!reference || reference.syntaxFiles.length === 0) {
+        // Fallback: get example contracts as syntax reference
+        const versionInfo = await releaseTracker.getVersionInfo(resolved.owner, resolved.repo);
+        const version = versionInfo.latestStableRelease?.tag || "main";
+        return {
+            repository: `${resolved.owner}/${resolved.repo}`,
+            version,
+            warning: "No grammar documentation found. Use example contracts as reference.",
+            syntaxFiles: [],
+            examplePaths: ["examples/", "test/", "contracts/"],
+        };
+    }
+    return {
+        repository: `${resolved.owner}/${resolved.repo}`,
+        version: reference.version,
+        syntaxFiles: reference.syntaxFiles.map((f) => ({
+            path: f.path,
+            content: f.content,
+        })),
+        note: `This is the authoritative syntax reference at version ${reference.version}. Use this to ensure contracts are compilable.`,
+    };
+}
+//# sourceMappingURL=handlers.js.map

package/dist/tools/repository/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Repository module exports
+ * Barrel file for repository-related tools
+ */
+export { GetFileInputSchema, ListExamplesInputSchema, GetLatestUpdatesInputSchema, GetVersionInfoInputSchema, CheckBreakingChangesInputSchema, GetMigrationGuideInputSchema, GetFileAtVersionInputSchema, CompareSyntaxInputSchema, GetLatestSyntaxInputSchema, type GetFileInput, type ListExamplesInput, type GetLatestUpdatesInput, type GetVersionInfoInput, type CheckBreakingChangesInput, type GetMigrationGuideInput, type GetFileAtVersionInput, type CompareSyntaxInput, type GetLatestSyntaxInput, } from "./schemas.js";
+export { REPO_ALIASES, EXAMPLES, type ExampleDefinition } from "./constants.js";
+export { resolveRepo, getFile, listExamples, getLatestUpdates, getVersionInfo, checkBreakingChanges, getMigrationGuide, getFileAtVersion, compareSyntax, getLatestSyntax, } from "./handlers.js";
+export { repositoryTools } from "./tools.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/repository/index.js

@@ -0,0 +1,13 @@
+/**
+ * Repository module exports
+ * Barrel file for repository-related tools
+ */
+// Schemas and types
+export { GetFileInputSchema, ListExamplesInputSchema, GetLatestUpdatesInputSchema, GetVersionInfoInputSchema, CheckBreakingChangesInputSchema, GetMigrationGuideInputSchema, GetFileAtVersionInputSchema, CompareSyntaxInputSchema, GetLatestSyntaxInputSchema, } from "./schemas.js";
+// Constants
+export { REPO_ALIASES, EXAMPLES } from "./constants.js";
+// Handlers
+export { resolveRepo, getFile, listExamples, getLatestUpdates, getVersionInfo, checkBreakingChanges, getMigrationGuide, getFileAtVersion, compareSyntax, getLatestSyntax, } from "./handlers.js";
+// Tools
+export { repositoryTools } from "./tools.js";
+//# sourceMappingURL=index.js.map