dsh-skills-anywhere 0.3.2

package/lib/cli.js

@@ -0,0 +1,501 @@
+#!/usr/bin/env node
+import { a as readSourcesFile, b as projectSourcesFile, d as findProjectRoot, g as AGENTS, i as readLock, l as writeSourcesFile, o as resolveSource, r as hasGit, s as sameRepository, t as SkillsAnywhereProvider, x as resolveConfig } from "./provider-C8Jncd8r.js";
+import { isAbsolute, relative, sep } from "node:path";
+import { parseArgs } from "node:util";
+//#region src/cli.ts
+/**
+* `dsh-skills-anywhere` command line: inspect what the provider would give
+* dsh, manage git sources, and diagnose skipped skills — without booting dsh.
+*
+* @module
+*/
+const HELP = `dsh-skills-anywhere — your skills, anywhere.
+
+Usage: dsh-skills-anywhere <command> [options]
+
+Commands
+  list                 Skills the provider would publish to dsh (default)
+  agents               Supported agents and which directories exist here
+  sources              Configured git sources and their synced commits
+  add <source>         Add a git source (owner/repo, owner/repo/sub/dir,
+                       https://github.com/o/r/tree/main/dir, git URL, or path)
+  remove <source>      Remove a git source
+  sync                 Clone or refresh every source now
+  doctor               Explain skipped, repaired, and duplicate skills
+  mcp                  Serve the same skills to any MCP client over stdio
+
+Options
+  --cwd <dir>          Project directory (default: current directory)
+  --project            add/remove: use <project>/.dsh/skills-anywhere.json
+  --ref <ref>          add: branch, tag, or commit
+  --path <dir>         add: sub-directory inside the repository
+  --rank <n>           add: precedence rank inside dsh (lower wins)
+  --force              sync: refresh even when pinned to a commit
+  --all                list: include dropped duplicates
+  --json               Machine-readable output
+  -h, --help           Show this help
+`;
+async function main(argv = process.argv.slice(2)) {
+	let parsed;
+	try {
+		parsed = parseArgs({
+			args: [...argv],
+			allowPositionals: true,
+			options: {
+				cwd: { type: "string" },
+				json: {
+					type: "boolean",
+					default: false
+				},
+				all: {
+					type: "boolean",
+					default: false
+				},
+				project: {
+					type: "boolean",
+					default: false
+				},
+				force: {
+					type: "boolean",
+					default: false
+				},
+				ref: { type: "string" },
+				path: { type: "string" },
+				rank: { type: "string" },
+				help: {
+					type: "boolean",
+					short: "h",
+					default: false
+				}
+			}
+		});
+	} catch (error) {
+		console.error(String(error instanceof Error ? error.message : error));
+		console.error(HELP);
+		return 2;
+	}
+	if (parsed.values.help) {
+		console.log(HELP);
+		return 0;
+	}
+	const [command = "list", ...positional] = parsed.positionals;
+	const cli = {
+		command,
+		positional,
+		cwd: parsed.values.cwd ?? process.cwd(),
+		json: parsed.values.json ?? false,
+		all: parsed.values.all ?? false,
+		project: parsed.values.project ?? false,
+		force: parsed.values.force ?? false,
+		...parsed.values.ref !== void 0 ? { ref: parsed.values.ref } : {},
+		...parsed.values.path !== void 0 ? { path: parsed.values.path } : {},
+		...parsed.values.rank !== void 0 ? { rank: Number(parsed.values.rank) } : {}
+	};
+	const config = resolveConfig({
+		watch: false,
+		sync: false
+	});
+	switch (command) {
+		case "list": return await list(cli, config);
+		case "agents": return agents(cli, config);
+		case "sources": return await sources(cli, config);
+		case "add": return await add(cli, config);
+		case "remove":
+		case "rm": return await remove(cli, config);
+		case "sync": return await sync(cli, config);
+		case "doctor": return await doctor(cli, config);
+		case "mcp": return await mcp(cli);
+		default:
+			console.error(`unknown command "${command}"\n`);
+			console.error(HELP);
+			return 2;
+	}
+}
+function logger() {
+	return {
+		info: (message) => console.error(message),
+		warn: (message) => console.error(message)
+	};
+}
+async function collect(cli, config) {
+	return (await collectWithSources(cli, config)).report;
+}
+/** One discovery pass plus the resolved git sources, so paths inside a source checkout can be shown repo-relative. */
+async function collectWithSources(cli, config) {
+	const provider = new SkillsAnywhereProvider(config, logger());
+	try {
+		await provider.list({ cwd: cli.cwd });
+		return {
+			report: provider.report() ?? {
+				skills: [],
+				dropped: [],
+				invalid: [],
+				roots: [],
+				complete: true
+			},
+			sourceDirs: (await provider.sources(cli.cwd)).map((source) => source.dir)
+		};
+	} finally {
+		await provider.dispose();
+	}
+}
+/** `~`-shortened path, or the path inside its git source checkout (the FROM column already names the repo). */
+function displayPath(path, config, sourceDirs) {
+	return sourceDirs.map((dir) => relative(dir, path)).filter((rel) => rel !== "" && !rel.startsWith("..") && !isAbsolute(rel)).toSorted((a, b) => a.length - b.length)[0] ?? shorten(path, config.home);
+}
+function originLabel(skill) {
+	const { origin } = skill;
+	switch (origin.kind) {
+		case "agent": return `${origin.agent ?? "agent"} (${origin.scope ?? "?"})`;
+		case "claude-plugins": return `claude plugin ${origin.plugin ?? "?"}${origin.marketplace !== void 0 ? ` @ ${origin.marketplace}` : ""}`;
+		case "source": return `source ${origin.repo ?? "?"}`;
+		default: return `custom (${origin.scope ?? "?"})`;
+	}
+}
+function table(rows) {
+	if (rows.length === 0) return "";
+	const widths = rows[0].map((_, column) => Math.max(...rows.map((row) => (row[column] ?? "").length)));
+	return rows.map((row) => row.map((cell, column) => cell.padEnd(widths[column] ?? 0)).join("  ").trimEnd()).join("\n");
+}
+async function list(cli, config) {
+	const { report, sourceDirs } = await collectWithSources(cli, config);
+	if (cli.json) {
+		console.log(JSON.stringify({
+			skills: report.skills.map((skill) => ({
+				name: skill.name,
+				description: skill.description,
+				source: skill.source,
+				rank: skill.rank,
+				path: skill.path,
+				origin: skill.origin,
+				warnings: skill.warnings
+			})),
+			...cli.all ? { dropped: report.dropped.map((entry) => ({
+				name: entry.skill.name,
+				path: entry.skill.path,
+				reason: entry.reason,
+				winner: entry.winner.path
+			})) } : {},
+			invalid: report.invalid.map((entry) => ({
+				path: entry.path,
+				reason: entry.reason
+			})),
+			complete: report.complete
+		}, null, 2));
+		return 0;
+	}
+	if (report.skills.length === 0) console.log("No skills found outside the dsh defaults. Try: dsh-skills-anywhere add anthropics/skills");
+	else console.log(table([[
+		"NAME",
+		"FROM",
+		"PATH"
+	], ...report.skills.map((skill) => [
+		skill.name,
+		originLabel(skill),
+		displayPath(skill.path, config, sourceDirs)
+	])]));
+	if (cli.all && report.dropped.length > 0) {
+		console.log(`\nDropped duplicates (${report.dropped.length}):`);
+		console.log(table(report.dropped.map((entry) => [
+			entry.skill.name,
+			entry.reason,
+			shorten(entry.skill.path, config.home),
+			`-> ${shorten(entry.winner.path, config.home)}`
+		])));
+	}
+	const renamed = report.skills.filter(isRenamed).length;
+	const repaired = report.skills.filter((skill) => skill.warnings.length > 0 && !isRenamed(skill)).length;
+	console.log(`\n${report.skills.length} skills` + (report.dropped.length > 0 ? `, ${report.dropped.length} duplicates hidden` : "") + (report.invalid.length > 0 ? `, ${report.invalid.length} skipped` : "") + (renamed > 0 ? `, ${renamed} renamed` : "") + (repaired > 0 ? `, ${repaired} repaired` : "") + (report.invalid.length + repaired + renamed > 0 ? " — run `dsh-skills-anywhere doctor` for details" : ""));
+	return 0;
+}
+function isRenamed(skill) {
+	return typeof skill.metadata.skillsAnywhere?.renamedFrom === "string";
+}
+async function agents(cli, config) {
+	const provider = new SkillsAnywhereProvider(config, logger());
+	try {
+		const roots = await provider.roots(cli.cwd);
+		const existing = new Set((await collect(cli, config)).roots.filter((root) => root.exists).map((root) => root.root.path));
+		const rows = AGENTS.map((agent) => {
+			const projectRoot = roots.find((root) => root.origin.kind === "agent" && root.origin.agent === agent.id && root.origin.scope === "project");
+			const userRoot = roots.find((root) => root.origin.kind === "agent" && root.origin.agent === agent.id && root.origin.scope === "user");
+			return {
+				id: agent.id,
+				label: agent.label,
+				project: agent.project ?? null,
+				user: agent.user !== void 0 ? `~/${agent.user}` : null,
+				present: projectRoot !== void 0 && existing.has(projectRoot.path) || userRoot !== void 0 && existing.has(userRoot.path)
+			};
+		});
+		if (cli.json) console.log(JSON.stringify(rows, null, 2));
+		else {
+			console.log(table([[
+				"AGENT",
+				"ID",
+				"PROJECT DIR",
+				"USER DIR",
+				"FOUND HERE"
+			], ...rows.map((row) => [
+				row.label,
+				row.id,
+				row.project ?? "-",
+				row.user ?? "-",
+				row.present ? "yes" : ""
+			])]));
+			console.log(`\n${rows.length} agents supported; ${rows.filter((row) => row.present).length} have a skills directory on this machine.`);
+			console.log("(.agents/skills and .dsh/skills are handled by the built-in dsh provider.)");
+		}
+		return 0;
+	} finally {
+		await provider.dispose();
+	}
+}
+async function sources(cli, config) {
+	const provider = new SkillsAnywhereProvider(config, logger());
+	try {
+		const resolved = await provider.sources(cli.cwd);
+		const lock = await readLock(config.lockFile);
+		if (cli.json) {
+			console.log(JSON.stringify(resolved.map((source) => ({
+				...source,
+				lock: lock[source.key] ?? null
+			})), null, 2));
+			return 0;
+		}
+		if (resolved.length === 0) {
+			console.log("No git sources configured. Add one with: dsh-skills-anywhere add owner/repo");
+			return 0;
+		}
+		console.log(table([[
+			"SOURCE",
+			"REF",
+			"SYNCED COMMIT",
+			"CACHE"
+		], ...resolved.map((source) => [
+			source.display,
+			source.ref ?? "(default)",
+			lock[source.key]?.sha.slice(0, 12) ?? "(never)",
+			shorten(source.dir, config.home)
+		])]));
+		console.log(`\nuser file:    ${shorten(config.userSourcesFile, config.home)}`);
+		console.log(`project file: ${shorten(projectSourcesFile(await findProjectRoot(cli.cwd)), config.home)}`);
+		return 0;
+	} finally {
+		await provider.dispose();
+	}
+}
+async function targetFile(cli, config) {
+	return cli.project ? projectSourcesFile(await findProjectRoot(cli.cwd)) : config.userSourcesFile;
+}
+async function add(cli, config) {
+	const input = cli.positional[0];
+	if (input === void 0) {
+		console.error("usage: dsh-skills-anywhere add <source> [--ref <ref>] [--path <dir>] [--rank <n>] [--project]");
+		return 2;
+	}
+	const spec = {
+		repo: input,
+		...cli.ref !== void 0 ? { ref: cli.ref } : {},
+		...cli.path !== void 0 ? { path: cli.path } : {},
+		...cli.rank !== void 0 && Number.isFinite(cli.rank) ? { rank: cli.rank } : {}
+	};
+	let resolved;
+	try {
+		resolved = resolveSource(spec, config.cacheDir);
+	} catch (error) {
+		console.error(String(error instanceof Error ? error.message : error));
+		return 2;
+	}
+	const file = await targetFile(cli, config);
+	const existing = await readSourcesFile(file);
+	if (existing.some((entry) => sameSourcePath(entry, resolved, config.cacheDir))) {
+		console.log(`${resolved.display} is already in ${shorten(file, config.home)}`);
+		return 0;
+	}
+	await writeSourcesFile(file, [...existing, spec]);
+	console.log(`added ${resolved.display} to ${shorten(file, config.home)}`);
+	if (!await hasGit()) {
+		console.error("git was not found on PATH; the source will sync once git is installed.");
+		return 0;
+	}
+	const provider = new SkillsAnywhereProvider(config, logger());
+	try {
+		const mine = (await provider.syncAll(cli.cwd)).find((result) => result.source.id === resolved.id);
+		if (mine !== void 0) printSync([mine], config);
+		const fromSource = (await collectWith(provider, cli)).skills.filter((skill) => skill.origin.kind === "source" && skill.origin.repo === resolved.display);
+		console.log(`${fromSource.length} skills available from ${resolved.display}`);
+		return mine?.status === "failed" ? 1 : 0;
+	} finally {
+		await provider.dispose();
+	}
+}
+async function collectWith(provider, cli) {
+	await provider.list({ cwd: cli.cwd });
+	return provider.report() ?? {
+		skills: [],
+		dropped: [],
+		invalid: [],
+		roots: [],
+		complete: true
+	};
+}
+/** Same repository and same sub-path, comparing resolved values so `o/r/sub` and `{ repo: 'o/r', path: 'sub' }` match. */
+function sameSourcePath(entry, resolved, cacheDir) {
+	try {
+		const other = resolveSource(entry, cacheDir);
+		return other.id === resolved.id && (other.path ?? "") === (resolved.path ?? "");
+	} catch {
+		return false;
+	}
+}
+async function remove(cli, config) {
+	const input = cli.positional[0];
+	if (input === void 0) {
+		console.error("usage: dsh-skills-anywhere remove <source> [--project]");
+		return 2;
+	}
+	const file = await targetFile(cli, config);
+	const existing = await readSourcesFile(file);
+	const remaining = existing.filter((entry) => !sameRepository(entry, input, config.cacheDir));
+	if (remaining.length === existing.length) {
+		console.error(`${input} is not listed in ${shorten(file, config.home)}`);
+		return 1;
+	}
+	await writeSourcesFile(file, remaining);
+	console.log(`removed ${input} from ${shorten(file, config.home)} (cached checkout kept under ${shorten(config.cacheDir, config.home)})`);
+	return 0;
+}
+async function sync(cli, config) {
+	const provider = new SkillsAnywhereProvider(config, logger());
+	try {
+		const results = await provider.syncAll(cli.cwd, { force: cli.force });
+		if (cli.json) console.log(JSON.stringify(results.map((result) => ({
+			source: result.source.display,
+			status: result.status,
+			sha: result.sha ?? null,
+			error: result.error ?? null
+		})), null, 2));
+		else if (results.length === 0) console.log("No git sources configured.");
+		else printSync(results, config);
+		return results.some((result) => result.status === "failed") ? 1 : 0;
+	} finally {
+		await provider.dispose();
+	}
+}
+function printSync(results, _config) {
+	console.log(table([[
+		"SOURCE",
+		"STATUS",
+		"COMMIT"
+	], ...results.map((result) => [
+		result.source.display,
+		result.status,
+		result.sha?.slice(0, 12) ?? result.error ?? ""
+	])]));
+}
+async function doctor(cli, config) {
+	const report = await collect(cli, config);
+	const git = await hasGit();
+	if (cli.json) {
+		console.log(JSON.stringify({
+			git,
+			roots: report.roots.map((root) => ({
+				label: root.root.label,
+				path: root.root.path,
+				exists: root.exists,
+				count: root.count
+			})),
+			renamed: report.skills.filter(isRenamed).map((skill) => ({
+				name: skill.name,
+				from: skill.metadata.skillsAnywhere.renamedFrom,
+				path: skill.path
+			})),
+			repaired: report.skills.filter((skill) => skill.warnings.length > 0 && !isRenamed(skill)).map((skill) => ({
+				name: skill.name,
+				path: skill.path,
+				warnings: skill.warnings
+			})),
+			invalid: report.invalid.map((entry) => ({
+				path: entry.path,
+				reason: entry.reason
+			})),
+			dropped: report.dropped.map((entry) => ({
+				name: entry.skill.name,
+				path: entry.skill.path,
+				reason: entry.reason,
+				winner: entry.winner.path
+			})),
+			complete: report.complete
+		}, null, 2));
+		return 0;
+	}
+	console.log(`git: ${git ? "available" : "NOT FOUND (git sources disabled)"}`);
+	console.log(`state: ${shorten(config.stateDir, config.home)}`);
+	const present = report.roots.filter((root) => root.exists);
+	console.log(`\nRoots present (${present.length} of ${report.roots.length}):`);
+	console.log(table(present.map((root) => [
+		root.root.label,
+		String(root.count).padStart(3),
+		shorten(root.root.path, config.home)
+	])));
+	const renamed = report.skills.filter(isRenamed);
+	if (renamed.length > 0) {
+		console.log(`\nRenamed to avoid collisions (${renamed.length}):`);
+		console.log(table(renamed.map((skill) => [
+			skill.metadata.skillsAnywhere.renamedFrom,
+			`-> ${skill.name}`,
+			shorten(skill.path, config.home)
+		])));
+	}
+	const repaired = report.skills.filter((skill) => skill.warnings.length > 0 && !isRenamed(skill));
+	if (repaired.length > 0) {
+		console.log(`\nRepaired frontmatter (${repaired.length}):`);
+		for (const skill of repaired) {
+			console.log(`  ${skill.name}  ${shorten(skill.path, config.home)}`);
+			for (const warning of skill.warnings) console.log(`    - ${warning}`);
+		}
+	}
+	if (report.invalid.length > 0) {
+		console.log(`\nSkipped (${report.invalid.length}):`);
+		for (const entry of report.invalid) console.log(`  ${shorten(entry.path, config.home)}\n    - ${entry.reason}`);
+	}
+	if (report.dropped.length > 0) {
+		console.log(`\nHidden duplicates (${report.dropped.length}):`);
+		console.log(table(report.dropped.map((entry) => [
+			entry.skill.name,
+			entry.reason,
+			shorten(entry.skill.path, config.home),
+			`-> ${shorten(entry.winner.path, config.home)}`
+		])));
+	}
+	if (!report.complete) console.log("\nWARNING: at least one root could not be read completely; see messages above.");
+	return 0;
+}
+async function mcp(cli) {
+	const { runStdio } = await import("./mcp.js");
+	await runStdio({
+		cwd: cli.cwd,
+		config: {
+			sync: true,
+			watch: false
+		}
+	});
+	return 0;
+}
+function shorten(path, home) {
+	if (path === home) return "~";
+	const rel = relative(home, path);
+	if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) return path;
+	return `~${sep}${rel}`;
+}
+if ((() => {
+	const entry = process.argv[1];
+	return entry !== void 0 && /(?:^|[\\/])(?:dsh-skills-anywhere|cli(?:\.js|\.ts)?)$/.test(entry);
+})()) main().then((code) => {
+	process.exitCode = code;
+}, (error) => {
+	console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+	process.exitCode = 1;
+});
+//#endregion
+export { main };

package/lib/index.d.ts

@@ -0,0 +1,40 @@
+import { A as SourceSpec, C as RankConfig, D as LockEntry, E as resolveConfig, F as readSourcesFile, I as resolveSource, L as sameRepository, M as SyncStatus, N as hasGit, O as LockFile, P as readLock, R as syncSource, S as DEFAULT_RANKS, T as projectSourcesFile, _ as normalizeSkillName, a as DiscoveredSkill, b as CatalogConfig, c as InvalidSkill, d as SkillRoot, f as discover, g as isSkillName, h as ParsedSkill, i as applyCatalogBudget, j as SyncResult, k as ResolvedSource, l as RootReport, m as ParseResult, n as ProviderLogger, o as DiscoveryReport, p as findProjectRoot, r as SkillsAnywhereProvider, s as DroppedSkill, t as CatalogState, u as SkillOrigin, v as parseSkillMarkdown, w as ResolvedConfig, x as Config, y as splitFrontmatter, z as writeSourcesFile } from "./provider-gYkY_3P9.js";
+import { Context } from "@deepseek-ai/cordis";
+//#region src/agents.d.ts
+/**
+ * Where other coding agents keep their Agent Skills.
+ *
+ * The table follows the conventions catalogued by the `skills` CLI
+ * (https://github.com/vercel-labs/skills) and each agent's own docs. Two rows
+ * are deliberately absent because the shipped `@deepseek-ai/dsh-skill-filesystem`
+ * provider already scans them: `.agents/skills` (project and `~/.agents/skills`)
+ * and `.dsh/skills`. Re-scanning them here would only produce duplicates.
+ *
+ * `project` is relative to the project root (nearest ancestor with `.git`, else
+ * the cwd). `user` is relative to the home directory. Either may be absent.
+ *
+ * @module
+ */
+interface AgentSpec {
+  /** Stable identifier, usable in `excludeAgents`. */
+  readonly id: string;
+  /** Human-readable product name. */
+  readonly label: string;
+  /** Project-level skills directory, relative to the project root. */
+  readonly project?: string;
+  /** User-level skills directory, relative to the home directory. */
+  readonly user?: string;
+}
+export declare const AGENTS: readonly AgentSpec[];
+/** Look up one agent by id. */
+export declare function agentById(id: string): AgentSpec | undefined;
+//#endregion
+//#region src/index.d.ts
+/** Cordis plugin name; stable across releases. */
+export declare const name = "skills-anywhere";
+/** The skill registry must exist before the provider can register. */
+export declare const inject: string[];
+/** Register the skills-anywhere provider on `ctx.skills`. */
+export declare function apply(ctx: Context, config?: Config): void;
+//#endregion
+export { type AgentSpec, type CatalogConfig, type CatalogState, Config, type Config as ConfigInput, DEFAULT_RANKS, type DiscoveredSkill, type DiscoveryReport, type DroppedSkill, type InvalidSkill, type LockEntry, type LockFile, type ParseResult, type ParsedSkill, type ProviderLogger, type RankConfig, type ResolvedConfig, type ResolvedSource, type RootReport, type SkillOrigin, type SkillRoot, SkillsAnywhereProvider, type SourceSpec, type SyncResult, type SyncStatus, applyCatalogBudget, discover, findProjectRoot, hasGit, isSkillName, normalizeSkillName, parseSkillMarkdown, projectSourcesFile, readLock, readSourcesFile, resolveConfig, resolveSource, sameRepository, splitFrontmatter, syncSource, writeSourcesFile };

package/lib/index.js

@@ -0,0 +1,25 @@
+import { _ as agentById, a as readSourcesFile, b as projectSourcesFile, c as syncSource, d as findProjectRoot, f as isSkillName, g as AGENTS, h as splitFrontmatter, i as readLock, l as writeSourcesFile, m as parseSkillMarkdown, n as applyCatalogBudget, o as resolveSource, p as normalizeSkillName, r as hasGit, s as sameRepository, t as SkillsAnywhereProvider, u as discover, v as Config, x as resolveConfig, y as DEFAULT_RANKS } from "./provider-C8Jncd8r.js";
+//#region src/index.ts
+/** Cordis plugin name; stable across releases. */
+const name = "skills-anywhere";
+/** The skill registry must exist before the provider can register. */
+const inject = ["skills"];
+/** Register the skills-anywhere provider on `ctx.skills`. */
+function apply(ctx, config = {}) {
+	const resolved = resolveConfig(config);
+	let provider;
+	ctx.skills.registerProvider((control) => {
+		provider = new SkillsAnywhereProvider(resolved, {
+			info: (message) => ctx.logger.info(message),
+			warn: (message) => ctx.logger.warn(message),
+			debug: (message) => ctx.logger.debug(message)
+		}, control);
+		return provider;
+	});
+	ctx.effect(() => () => {
+		provider.dispose();
+	}, "skills-anywhere provider");
+	ctx.logger.info(`skills-anywhere: provider "${resolved.providerName}" registered (agents=${resolved.agents}, claudePlugins=${resolved.claudePlugins}, sources=${resolved.sources.length}${resolved.sourcesFiles ? "+files" : ""})`);
+}
+//#endregion
+export { AGENTS, Config, DEFAULT_RANKS, SkillsAnywhereProvider, agentById, apply, applyCatalogBudget, discover, findProjectRoot, hasGit, inject, isSkillName, name, normalizeSkillName, parseSkillMarkdown, projectSourcesFile, readLock, readSourcesFile, resolveConfig, resolveSource, sameRepository, splitFrontmatter, syncSource, writeSourcesFile };

package/lib/mcp.d.ts

@@ -0,0 +1,48 @@
+import { a as DiscoveredSkill, n as ProviderLogger, o as DiscoveryReport, r as SkillsAnywhereProvider, w as ResolvedConfig, x as Config } from "./provider-gYkY_3P9.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+//#region src/mcp.d.ts
+export interface McpOptions {
+  /** Project directory that selects project-level skill roots and sources. */
+  readonly cwd?: string;
+  /** Provider configuration; defaults follow the dsh plugin defaults. */
+  readonly config?: Config | ResolvedConfig;
+  /** Where diagnostics go. Defaults to stderr, which stdio MCP clients ignore. */
+  readonly log?: ProviderLogger;
+  /** How long one discovery pass is reused before rescanning (ms). */
+  readonly cacheMs?: number;
+  /** Default `find_skills` result count. */
+  readonly findLimit?: number;
+  /** Hard cap for `find_skills` and `list_skills` result counts. */
+  readonly maxLimit?: number;
+}
+export interface SkillsAnywhereMcp {
+  readonly server: McpServer;
+  readonly provider: SkillsAnywhereProvider;
+  /** Discover (or reuse the cached pass) and return the current pool. */
+  refresh(force?: boolean): Promise<DiscoveryReport>;
+  /** Close the transport and release watchers and timers. */
+  close(): Promise<void>;
+}
+export interface OpenedSkill {
+  readonly name: string;
+  readonly description: string;
+  readonly directory: string;
+  readonly path: string;
+  readonly source: string;
+  readonly content: string;
+}
+export declare function packageVersion(): string;
+/** Skills the author allows a model to invoke, in catalog order. */
+export declare function modelSkills(report: DiscoveryReport): DiscoveredSkill[];
+/**
+ * Render a skill the way dsh hands it to its model, so clients that already
+ * understand `<skill_content>` blocks see a familiar shape.
+ */
+export declare function renderSkill(skill: Pick<OpenedSkill, 'name' | 'directory' | 'content'>): string;
+/** Re-read a discovered skill from disk so edits since discovery are honoured. */
+export declare function openSkill(skill: DiscoveredSkill, lenient: boolean): Promise<OpenedSkill | undefined>;
+/** Build a server over a standalone provider. Nothing is connected yet. */
+export declare function createSkillsAnywhereServer(options?: McpOptions): SkillsAnywhereMcp;
+/** Serve over stdio until the client disconnects; resolves when closed. */
+export declare function runStdio(options?: McpOptions): Promise<void>;
+//#endregion