@nseng-ai/areg 0.1.1

package/src/gateways/prompt-gateway.ts

@@ -0,0 +1,21 @@
+import readline from "node:readline/promises";
+
+import type { AregPromptGateway } from "../gateways.ts";
+
+export class RealAregPromptGateway implements AregPromptGateway {
+	async confirm(request: { message: string; defaultValue: boolean }): Promise<boolean> {
+		const suffix = request.defaultValue ? " [Y/n] " : " [y/N] ";
+		const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+		try {
+			while (true) {
+				const answer = (await rl.question(`${request.message}${suffix}`)).trim().toLowerCase();
+				if (answer.length === 0) return request.defaultValue;
+				if (answer === "y" || answer === "yes") return true;
+				if (answer === "n" || answer === "no") return false;
+				process.stdout.write("Please answer yes or no.\n");
+			}
+		} finally {
+			rl.close();
+		}
+	}
+}

package/src/gateways/skill-kind-classification.ts

@@ -0,0 +1,39 @@
+import type { AregSkillKindResolveResult, AregSkillKindSkillInspection } from "../gateways.ts";
+import { errorInfo } from "./errors.ts";
+
+export function classifyResolvedSkillKindInspection(options: {
+	spec: string;
+	skillName: string;
+	inspection: AregSkillKindSkillInspection;
+}): AregSkillKindResolveResult {
+	if (options.inspection.skillDir.type === "symlink")
+		return {
+			type: "error",
+			error: errorInfo(
+				"skill-kind-symlink-skill-dir",
+				`${options.inspection.baseRelativePath} is a symlink; refusing to manage invocation metadata`,
+			),
+		};
+	if (options.inspection.skillDir.type !== "directory")
+		return {
+			type: "error",
+			error: errorInfo("skill-kind-missing-skill", `Managed skill not found: ${options.spec}`),
+		};
+	if (options.inspection.skillMd.type === "symlink")
+		return {
+			type: "error",
+			error: errorInfo(
+				"skill-kind-symlink-skill-md",
+				`${options.inspection.baseRelativePath}/SKILL.md is a symlink; refusing to manage invocation metadata`,
+			),
+		};
+	if (options.inspection.skillMd.type !== "file")
+		return {
+			type: "error",
+			error: errorInfo(
+				"skill-kind-missing-skill-md",
+				`${options.inspection.baseRelativePath}/SKILL.md does not exist`,
+			),
+		};
+	return { type: "ok", skillName: options.skillName };
+}

package/src/gateways/skillx-workspace-gateway.ts

@@ -0,0 +1,220 @@
+import { lstat, mkdtemp, readdir, realpath, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import { formatErrorMessage } from "@nseng-ai/foundation/primitives";
+import { resultErr, resultOk } from "@nseng-ai/foundation/result";
+
+import type {
+	AregErrorInfo,
+	AregNpxSkillsGateway,
+	AregOperationResult,
+	AregSkillxInstallRequest,
+	AregSkillxInstallResult,
+	AregSkillxInstalledSkill,
+	AregSkillxWorkspaceGateway,
+} from "../gateways.ts";
+import { sortStrings } from "../sort.ts";
+import { errorInfo } from "./errors.ts";
+import { inspectPath, isNodeErrorCode, isPathAtOrBelow } from "./fs-utils.ts";
+
+export class RealAregSkillxWorkspaceGateway implements AregSkillxWorkspaceGateway {
+	private readonly npxSkills: AregNpxSkillsGateway;
+
+	constructor(options: { npxSkills: AregNpxSkillsGateway }) {
+		this.npxSkills = options.npxSkills;
+	}
+
+	async installIntoWorkspace(request: AregSkillxInstallRequest): Promise<AregSkillxInstallResult> {
+		const workspaceRoot = await mkdtemp(path.join(os.tmpdir(), "skillx."));
+		const install = await this.npxSkills.addSkills({
+			sourceRepo: request.sourceRepo,
+			skillNames: request.skillName === undefined ? [] : [request.skillName],
+			targetAgents: ["codex"],
+			cwd: workspaceRoot,
+			env: request.env,
+		});
+		if (install.type === "error") {
+			await removeWorkspaceQuietly(workspaceRoot);
+			return {
+				type: "error",
+				error: errorInfo(
+					"skillx-install-failed",
+					`npx skills add failed: ${install.error.message}`,
+					install.error.displayCommand,
+				),
+			};
+		}
+		const inspected = await inspectInstalledSkills(workspaceRoot, request.skillName);
+		if (inspected.type === "error") {
+			await removeWorkspaceQuietly(workspaceRoot);
+			return { type: "error", error: inspected.error };
+		}
+		return { type: "ok", workspace: { workspaceRoot, installedSkills: inspected.installedSkills } };
+	}
+
+	async cleanupWorkspace(request: { workspaceRoot: string }): Promise<AregOperationResult> {
+		return await cleanupSkillxWorkspace(request.workspaceRoot);
+	}
+}
+
+async function inspectInstalledSkills(
+	workspaceRoot: string,
+	requestedSkillName: string | undefined,
+): Promise<
+	| { type: "ok"; installedSkills: AregSkillxInstalledSkill[] }
+	| { type: "error"; error: AregErrorInfo }
+> {
+	const skillsRoot = path.join(workspaceRoot, ".agents", "skills");
+	const skillsRootState = await inspectPath(skillsRoot);
+	if (skillsRootState.type !== "directory")
+		return { type: "error", error: errorInfo("skillx-no-skills", "No skills were installed") };
+	if (requestedSkillName !== undefined) {
+		const inspected = await inspectOneSkill(skillsRoot, requestedSkillName);
+		if (inspected.type === "error") return inspected;
+		return { type: "ok", installedSkills: [inspected.skill] };
+	}
+	const entries = await readdir(skillsRoot, { withFileTypes: true });
+	const skillNames = sortStrings(
+		entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name),
+	);
+	if (skillNames.length === 0)
+		return { type: "error", error: errorInfo("skillx-no-skills", "No skills were installed") };
+	const installedSkills: AregSkillxInstalledSkill[] = [];
+	for (const skillName of skillNames) {
+		const inspected = await inspectOneSkill(skillsRoot, skillName);
+		if (inspected.type === "error") return inspected;
+		installedSkills.push(inspected.skill);
+	}
+	return { type: "ok", installedSkills };
+}
+
+async function inspectOneSkill(
+	skillsRoot: string,
+	skillName: string,
+): Promise<
+	{ type: "ok"; skill: AregSkillxInstalledSkill } | { type: "error"; error: AregErrorInfo }
+> {
+	const directory = path.join(skillsRoot, skillName);
+	const directoryKind = await inspectPath(directory);
+	if (directoryKind.type !== "directory")
+		return {
+			type: "error",
+			error: errorInfo(
+				"skillx-skill-missing",
+				`Skill '${skillName}' was not found in installed skills`,
+			),
+		};
+	const skillFile = path.join(directory, "SKILL.md");
+	const fileKind = await inspectPath(skillFile);
+	if (fileKind.type !== "file")
+		return {
+			type: "error",
+			error: errorInfo(
+				"skillx-skill-malformed",
+				`Installed skill '${skillName}' is missing SKILL.md`,
+			),
+		};
+	return {
+		type: "ok",
+		skill: {
+			name: skillName,
+			directory,
+			skillFile,
+			relativeFiles: await listRelativeFiles(directory),
+		},
+	};
+}
+
+async function listRelativeFiles(root: string): Promise<string[]> {
+	const files: string[] = [];
+	async function visit(directory: string, prefix: string): Promise<void> {
+		const entries = await readdir(directory, { withFileTypes: true });
+		entries.sort((left, right) => left.name.localeCompare(right.name));
+		for (const entry of entries) {
+			const relativePath = prefix.length === 0 ? entry.name : `${prefix}/${entry.name}`;
+			const fullPath = path.join(directory, entry.name);
+			if (entry.isDirectory()) {
+				await visit(fullPath, relativePath);
+				continue;
+			}
+			if (entry.isFile()) files.push(relativePath);
+		}
+	}
+	await visit(root, "");
+	return sortStrings(files);
+}
+
+async function cleanupSkillxWorkspace(workspaceRoot: string): Promise<AregOperationResult> {
+	if (!path.basename(workspaceRoot).startsWith("skillx.")) {
+		return resultErr(
+			errorInfo(
+				"skillx-cleanup-refused",
+				`Refusing to remove non-skillx workspace: ${workspaceRoot}`,
+			),
+		);
+	}
+	let info;
+	try {
+		info = await lstat(workspaceRoot);
+	} catch (error) {
+		if (isNodeErrorCode(error, "ENOENT"))
+			return resultErr(
+				errorInfo("skillx-cleanup-missing", `Workspace does not exist: ${workspaceRoot}`),
+			);
+		return resultErr(
+			errorInfo(
+				"skillx-cleanup-stat-failed",
+				`Could not inspect workspace: ${formatErrorMessage(error)}`,
+			),
+		);
+	}
+	if (info.isSymbolicLink())
+		return resultErr(
+			errorInfo("skillx-cleanup-symlink", `Refusing to remove symlink workspace: ${workspaceRoot}`),
+		);
+	if (!info.isDirectory())
+		return resultErr(
+			errorInfo("skillx-cleanup-not-directory", `Workspace is not a directory: ${workspaceRoot}`),
+		);
+	let resolvedWorkspace: string;
+	let resolvedTemp: string;
+	try {
+		resolvedWorkspace = await realpath(workspaceRoot);
+		resolvedTemp = await realpath(os.tmpdir());
+	} catch (error) {
+		return resultErr(
+			errorInfo(
+				"skillx-cleanup-realpath-failed",
+				`Could not resolve workspace path: ${formatErrorMessage(error)}`,
+			),
+		);
+	}
+	if (!isPathAtOrBelow(resolvedWorkspace, resolvedTemp)) {
+		return resultErr(
+			errorInfo(
+				"skillx-cleanup-outside-temp",
+				`Refusing to remove workspace outside temp directory: ${workspaceRoot}`,
+			),
+		);
+	}
+	try {
+		await rm(resolvedWorkspace, { recursive: true });
+		return resultOk(undefined);
+	} catch (error) {
+		return resultErr(
+			errorInfo(
+				"skillx-cleanup-remove-failed",
+				`Could not remove workspace: ${formatErrorMessage(error)}`,
+			),
+		);
+	}
+}
+
+async function removeWorkspaceQuietly(workspaceRoot: string): Promise<void> {
+	try {
+		await rm(workspaceRoot, { recursive: true, force: true });
+	} catch {
+		// Best-effort cleanup of a directory this gateway just created; the command result carries the original failure.
+	}
+}

package/src/gateways.ts

@@ -0,0 +1,361 @@
+import {
+	SKILL_LOOKUP_ROOT_DESCRIPTORS,
+	skillLookupDescriptorForSourceType,
+} from "./skill-lookup.ts";
+import type {
+	SkillLookupRoot,
+	SkillLookupRootDescriptor,
+	SkillLookupSourceType,
+} from "./skill-lookup.ts";
+import type { ErrorInfo, Result } from "@nseng-ai/foundation/result";
+
+export const AREG_HOST_TOOL_NAMES = ["gh", "npx"] as const;
+export type AregHostToolName = (typeof AREG_HOST_TOOL_NAMES)[number];
+
+export interface AregErrorInfo extends ErrorInfo {
+	displayCommand?: string;
+}
+
+export type AregOperationResult = Result<undefined, AregErrorInfo>;
+
+export type AregToolCheckResult =
+	| { type: "found"; tool: AregHostToolName; path: string }
+	| { type: "missing"; tool: AregHostToolName; message: string };
+
+export interface AregHostGateway {
+	checkTool(options: {
+		tool: AregHostToolName;
+		cwd: string;
+		env: NodeJS.ProcessEnv;
+	}): Promise<AregToolCheckResult>;
+}
+
+export type AregGithubSkillListResult =
+	| { type: "ok"; skillNames: readonly string[] }
+	| { type: "missing"; message: string }
+	| { type: "auth-error"; message: string }
+	| { type: "error"; error: AregErrorInfo };
+
+export type AregGithubSkillFileResult =
+	| { type: "found" }
+	| { type: "missing"; message: string }
+	| { type: "auth-error"; message: string }
+	| { type: "error"; error: AregErrorInfo };
+
+export interface AregGithubGateway {
+	listSkillDirectoryNames(options: {
+		repo: string;
+		ref?: string;
+		env: NodeJS.ProcessEnv;
+	}): Promise<AregGithubSkillListResult>;
+	checkSkillFile(options: {
+		repo: string;
+		path: string;
+		ref?: string;
+		env: NodeJS.ProcessEnv;
+	}): Promise<AregGithubSkillFileResult>;
+}
+
+export interface AregNpxSkillsAddRequest {
+	sourceRepo: string;
+	/** Empty means install all skills from the source repository. */
+	skillNames: readonly string[];
+	targetAgents: readonly string[];
+	cwd: string;
+	env: NodeJS.ProcessEnv;
+}
+
+export type AregNpxSkillsAddResult = { type: "ok" } | { type: "error"; error: AregErrorInfo };
+
+export interface AregNpxSkillsGateway {
+	addSkills(request: AregNpxSkillsAddRequest): Promise<AregNpxSkillsAddResult>;
+}
+
+export interface AregPromptGateway {
+	confirm(request: { message: string; defaultValue: boolean }): Promise<boolean>;
+}
+
+export interface AregSkillxInstalledSkill {
+	name: string;
+	directory: string;
+	skillFile: string;
+	relativeFiles: readonly string[];
+}
+
+export interface AregSkillxWorkspaceInstall {
+	workspaceRoot: string;
+	installedSkills: readonly AregSkillxInstalledSkill[];
+}
+
+export interface AregSkillxInstallRequest {
+	sourceRepo: string;
+	skillName?: string;
+	cwd: string;
+	env: NodeJS.ProcessEnv;
+}
+
+export interface AregSkillxWorkspaceCleanupRequest {
+	workspaceRoot: string;
+}
+
+export type AregSkillxInstallResult =
+	| { type: "ok"; workspace: AregSkillxWorkspaceInstall }
+	| { type: "error"; error: AregErrorInfo };
+
+export interface AregSkillxWorkspaceGateway {
+	installIntoWorkspace(request: AregSkillxInstallRequest): Promise<AregSkillxInstallResult>;
+	cleanupWorkspace(request: AregSkillxWorkspaceCleanupRequest): Promise<AregOperationResult>;
+}
+
+export type AregPathState =
+	| { type: "missing" }
+	| { type: "file" }
+	| { type: "directory" }
+	| { type: "symlink"; target: string }
+	| { type: "other" };
+
+export type AregTextFileState =
+	| { type: "missing" }
+	| { type: "file"; text: string }
+	| { type: "directory" }
+	| { type: "symlink"; target: string }
+	| { type: "other" }
+	| { type: "unreadable"; message: string };
+
+export interface AregCheckSkillInspection {
+	name: string;
+	skillsPath: AregPathState;
+	agentsPath: AregPathState;
+	claudePath: AregPathState;
+	localSkillMd: AregTextFileState;
+	remoteSkillMd: AregTextFileState;
+	openaiPolicy: AregTextFileState;
+}
+
+export function missingCheckSkillInspection(name: string): AregCheckSkillInspection {
+	const missing = { type: "missing" as const };
+	return {
+		name,
+		skillsPath: missing,
+		agentsPath: missing,
+		claudePath: missing,
+		localSkillMd: missing,
+		remoteSkillMd: missing,
+		openaiPolicy: missing,
+	};
+}
+
+export interface AregCheckPairingDirectory {
+	relativeDir: string;
+	hasAgents: boolean;
+	hasClaude: boolean;
+	claudeText?: string;
+}
+
+export type AregSkillKindSourceType = Extract<SkillLookupSourceType, "repo" | "vendored">;
+export type AregSkillKindRootDescriptor = Extract<
+	SkillLookupRootDescriptor,
+	{ sourceType: AregSkillKindSourceType }
+>;
+
+export const AREG_SKILL_KIND_ROOT_DESCRIPTORS = SKILL_LOOKUP_ROOT_DESCRIPTORS.filter(
+	(descriptor): descriptor is AregSkillKindRootDescriptor =>
+		descriptor.sourceType === "repo" || descriptor.sourceType === "vendored",
+);
+
+export function skillKindDescriptorForSourceType(
+	sourceType: AregSkillKindSourceType,
+): AregSkillKindRootDescriptor {
+	const descriptor = skillLookupDescriptorForSourceType(sourceType);
+	if (descriptor.sourceType !== "repo" && descriptor.sourceType !== "vendored") {
+		throw new Error(`Unknown skill-kind source type: ${sourceType}`);
+	}
+	return descriptor;
+}
+
+export interface AregSkillFindSkillInspection {
+	name: string;
+	root: SkillLookupRoot;
+	sourceType: SkillLookupSourceType;
+	baseRelativePath: string;
+	skillDir: AregPathState;
+	skillMd: AregTextFileState;
+}
+
+export interface AregSkillFindRootsInspection {
+	skills: readonly AregSkillFindSkillInspection[];
+}
+
+export interface AregSkillKindSkillInspection {
+	name: string;
+	sourceType: AregSkillKindSourceType;
+	baseRelativePath: string;
+	skillDir: AregPathState;
+	skillMd: AregTextFileState;
+	openaiPolicy: AregTextFileState;
+	agentsPath: AregPathState;
+	claudePath: AregPathState;
+}
+
+export interface AregReplacementInspection {
+	verifiedSurfaces: readonly string[];
+}
+
+export interface AregProjectInspectionRequest {
+	cwd: string;
+	projectPath: string;
+	env: NodeJS.ProcessEnv;
+}
+
+export interface AregProjectDirRequest {
+	projectDir: string;
+	env: NodeJS.ProcessEnv;
+}
+
+export interface AregSkillInspectionRequest {
+	projectDir: string;
+	skillName: string;
+	env: NodeJS.ProcessEnv;
+}
+
+export interface AregProjectBaseInspection {
+	projectDir: string;
+	projectPathState: AregPathState;
+	lockfile: AregTextFileState;
+	nsToml: AregTextFileState;
+	aregJson: AregTextFileState;
+}
+
+export interface AregInstructionFilesInspection {
+	agentsMd: AregTextFileState;
+	claudeMd: AregTextFileState;
+	claudeDir: AregPathState;
+	claudeSettings: AregTextFileState;
+}
+
+export interface AregPiArtifactsInspection {
+	piDir: AregPathState;
+	piSettings: AregTextFileState;
+	replacement: AregReplacementInspection;
+}
+
+export interface AregPiSkillInventoryInspection {
+	skillNames: readonly string[];
+	isApproximation: boolean;
+	source: string;
+}
+
+export interface AregSkillNameInventory {
+	skillsDirectoryNames: readonly string[];
+	agentsSkillNames: readonly string[];
+	claudeSkillNames: readonly string[];
+	skillKindNames: readonly string[];
+}
+
+export interface AregSkillKindResolveRequest {
+	projectDir: string;
+	spec: string;
+	cwd: string;
+	env: NodeJS.ProcessEnv;
+}
+
+export type AregSkillKindResolveResult =
+	| { type: "ok"; skillName: string }
+	| { type: "error"; error: AregErrorInfo };
+
+export type AregProjectMutationPolicy = "init" | "skill-kind";
+
+export interface AregProjectTextWriteRequest {
+	projectDir: string;
+	relativePath: string;
+	content: string;
+	description: string;
+	createParent: boolean;
+	policy: AregProjectMutationPolicy;
+	env: NodeJS.ProcessEnv;
+}
+
+export interface AregProjectManagedTargetRequest {
+	projectDir: string;
+	relativePath: string;
+	description: string;
+	policy: "skill-kind";
+	env: NodeJS.ProcessEnv;
+}
+
+export type AregProjectFileDeleteRequest = AregProjectManagedTargetRequest;
+export type AregProjectRemoveEmptyDirRequest = AregProjectManagedTargetRequest;
+export type AregProjectSymlinkDeleteRequest = AregProjectManagedTargetRequest;
+
+export type AregProjectMutationResult = { ok: true } | { ok: false; error: AregErrorInfo };
+export type AregProjectRemoveEmptyDirResult =
+	| { ok: true; removed: boolean }
+	| { ok: false; error: AregErrorInfo };
+
+/**
+ * Areg's project-resource gateway.
+ *
+ * This is intentionally domain-oriented: it exposes named areg project facts and
+ * project-scoped safe mutation primitives, not a generic filesystem API. Add new
+ * reads here only when they represent stable areg project concepts, and route new
+ * writes/deletes through project-scoped primitives with an explicit policy. Do not
+ * add an unrestricted filesystem gateway to areg as a convenience for operation code.
+ */
+export interface AregProjectGateway {
+	inspectProjectBase(request: AregProjectInspectionRequest): Promise<AregProjectBaseInspection>;
+	inspectInstructionFiles(request: AregProjectDirRequest): Promise<AregInstructionFilesInspection>;
+	inspectPiArtifacts(request: AregProjectDirRequest): Promise<AregPiArtifactsInspection>;
+	inspectPiSkillInventory(request: AregProjectDirRequest): Promise<AregPiSkillInventoryInspection>;
+	inspectSkillNameInventory(request: AregProjectDirRequest): Promise<AregSkillNameInventory>;
+	inspectSkillFindRoots(request: AregProjectDirRequest): Promise<AregSkillFindRootsInspection>;
+	inspectCheckSkill(request: AregSkillInspectionRequest): Promise<AregCheckSkillInspection>;
+	inspectSkillKindSkill(request: AregSkillInspectionRequest): Promise<AregSkillKindSkillInspection>;
+	inspectPairingDirectories(
+		request: AregProjectDirRequest,
+	): Promise<readonly AregCheckPairingDirectory[]>;
+	readLocallyExcludedSkillNames(request: AregProjectDirRequest): Promise<readonly string[]>;
+	resolveSkillKindSpec(request: AregSkillKindResolveRequest): Promise<AregSkillKindResolveResult>;
+	preflightWriteTextFile(request: AregProjectTextWriteRequest): Promise<AregProjectMutationResult>;
+	preflightDeleteFile(request: AregProjectFileDeleteRequest): Promise<AregProjectMutationResult>;
+	preflightDeleteSymlink(
+		request: AregProjectSymlinkDeleteRequest,
+	): Promise<AregProjectMutationResult>;
+	preflightRemoveEmptyDir(
+		request: AregProjectRemoveEmptyDirRequest,
+	): Promise<AregProjectMutationResult>;
+	writeTextFile(request: AregProjectTextWriteRequest): Promise<AregProjectMutationResult>;
+	deleteFile(request: AregProjectFileDeleteRequest): Promise<AregProjectMutationResult>;
+	deleteSymlink(request: AregProjectSymlinkDeleteRequest): Promise<AregProjectMutationResult>;
+	removeEmptyDir(
+		request: AregProjectRemoveEmptyDirRequest,
+	): Promise<AregProjectRemoveEmptyDirResult>;
+}
+
+export interface AregInitTextWritePlan {
+	relativePath: "ns.toml" | "AGENTS.md" | "CLAUDE.md" | ".claude/settings.local.json";
+	content: string;
+	description: string;
+	createParent: boolean;
+}
+
+export interface AregSkillKindTextWritePlan {
+	relativePath: string;
+	content: string;
+	description: string;
+	createParent: boolean;
+}
+
+export interface AregSkillKindDeletePlan {
+	relativePath: string;
+	description: string;
+}
+
+export interface AregSkillKindDeleteSymlinkPlan {
+	relativePath: string;
+	description: string;
+}
+
+export interface AregSkillKindRemoveEmptyDirPlan {
+	relativePath: string;
+	description: string;
+}

package/src/index.ts

@@ -0,0 +1,48 @@
+export { buildCli, runCli, VERSION, type CliDeps } from "./cli.ts";
+export { createRealAregContext, type AregCliContext } from "./context.ts";
+export type {
+	AregCheckPairingDirectory,
+	AregCheckSkillInspection,
+	AregErrorInfo,
+	AregReplacementInspection,
+	AregGithubGateway,
+	AregGithubSkillListResult,
+	AregHostGateway,
+	AregHostToolName,
+	AregNpxSkillsAddRequest,
+	AregNpxSkillsAddResult,
+	AregNpxSkillsGateway,
+	AregOperationResult,
+	AregPathState,
+	AregProjectBaseInspection,
+	AregProjectDirRequest,
+	AregProjectGateway,
+	AregProjectInspectionRequest,
+	AregProjectMutationPolicy,
+	AregProjectMutationResult,
+	AregProjectRemoveEmptyDirResult,
+	AregProjectTextWriteRequest,
+	AregPromptGateway,
+	AregSkillInspectionRequest,
+	AregSkillKindResolveRequest,
+	AregSkillKindResolveResult,
+	AregSkillKindSkillInspection,
+	AregSkillxInstallRequest,
+	AregSkillxInstallResult,
+	AregSkillxInstalledSkill,
+	AregSkillxWorkspaceCleanupRequest,
+	AregSkillxWorkspaceGateway,
+	AregSkillxWorkspaceInstall,
+	AregTextFileState,
+	AregToolCheckResult,
+} from "./gateways.ts";
+export { parseLockfileData, parseSkillFrontmatterText } from "./operations/check.ts";
+export { parseSkillInput } from "./operations/skillx.ts";
+export {
+	buildNpxSkillsAddArgs,
+	RealAregGithubGateway,
+	RealAregHostGateway,
+	RealAregNpxSkillsGateway,
+	RealAregProjectGateway,
+	RealAregSkillxWorkspaceGateway,
+} from "./real-gateways.ts";