@nseng-ai/areg 0.1.1 → 0.1.2

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

@@ -1,220 +0,0 @@
-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/operations/frontmatter.ts

@@ -1,151 +0,0 @@
-import {
-	splitMarkdownFrontmatter,
-	stripLineEnding,
-} from "@nseng-ai/foundation/markdown-frontmatter";
-import { err, type Result } from "@nseng-ai/foundation/result";
-
-const FRONTMATTER_KEY_RE = /^(?<key>[A-Za-z0-9_-]+):(?<value>.*)$/u;
-
-export interface SkillFrontmatterData {
-	fields: Readonly<Record<string, string>>;
-	keys: ReadonlySet<string>;
-}
-
-export type SkillFrontmatterParseResult = Result<SkillFrontmatterData>;
-
-export type SkillFrontmatterTopLevelLineParseResult =
-	| { type: "key"; key: string; value: string }
-	| { type: "not_top_level" }
-	| { type: "invalid"; line: string };
-
-export function parseSkillFrontmatterBlock(text: string): SkillFrontmatterParseResult {
-	const split = splitMarkdownFrontmatter(text);
-	if (split.type === "not_found")
-		return err({
-			code: "frontmatter_missing_opening_delimiter",
-			message: "missing opening frontmatter delimiter '---'",
-		});
-	if (split.type === "missing_closing_fence")
-		return err({
-			code: "frontmatter_missing_closing_delimiter",
-			message: "missing closing frontmatter delimiter '---'",
-		});
-
-	const lines = split.block.frontmatterLinesWithEndings.map(stripLineEnding);
-	const fields: Record<string, string> = {};
-	const keys = new Set<string>();
-	let currentKey: string | undefined;
-	let currentValues: string[] = [];
-	function flushCurrent(): void {
-		if (currentKey === undefined) return;
-		let rawValue = currentValues
-			.filter((value) => value.length > 0)
-			.join(" ")
-			.trim();
-		if (
-			rawValue.length >= 2 &&
-			rawValue[0] === rawValue.at(-1) &&
-			(rawValue[0] === '"' || rawValue[0] === "'")
-		)
-			rawValue = rawValue.slice(1, -1);
-		fields[currentKey] = rawValue;
-	}
-	for (const line of lines) {
-		const stripped = line.trim();
-		if (stripped.length === 0) continue;
-		if (stripped.startsWith("#")) continue;
-		const parsedLine = parseSkillFrontmatterTopLevelLine(line);
-		if (parsedLine.type === "key") {
-			flushCurrent();
-			if (keys.has(parsedLine.key))
-				return err({
-					code: "frontmatter_duplicate_key",
-					message: `duplicate frontmatter key: ${JSON.stringify(parsedLine.key)}`,
-				});
-			currentKey = parsedLine.key;
-			keys.add(currentKey);
-			currentValues = [];
-			const inlineValue = parsedLine.value.trim();
-			if (inlineValue.length > 0) currentValues.push(inlineValue);
-			continue;
-		}
-		if (parsedLine.type === "invalid")
-			return err({
-				code: "frontmatter_invalid_line",
-				message: `invalid frontmatter line: ${JSON.stringify(parsedLine.line)}`,
-			});
-		if (currentKey === undefined)
-			return err({
-				code: "frontmatter_invalid_line",
-				message: `invalid frontmatter line: ${JSON.stringify(line)}`,
-			});
-		currentValues.push(line.trim());
-	}
-	flushCurrent();
-	return { ok: true, value: { fields, keys } };
-}
-
-export function parseSkillFrontmatterTopLevelLine(
-	line: string,
-): SkillFrontmatterTopLevelLineParseResult {
-	const content = stripLineEnding(line);
-	if (content.trim().length === 0) return { type: "not_top_level" };
-	if (content.trim().startsWith("#")) return { type: "not_top_level" };
-	if (content.startsWith(" ") || content.startsWith("\t")) return { type: "not_top_level" };
-	const match = FRONTMATTER_KEY_RE.exec(content);
-	if (match?.groups === undefined) return { type: "invalid", line: content };
-	return { type: "key", key: match.groups.key ?? "", value: match.groups.value ?? "" };
-}
-
-export function isSkillFrontmatterTopLevelKey(line: string, key: string): boolean {
-	const parsed = parseSkillFrontmatterTopLevelLine(line);
-	return parsed.type === "key" && parsed.key === key;
-}
-
-export function transformSkillFrontmatter(
-	text: string,
-	pathLabel: string,
-	desired: Readonly<Record<string, string | undefined>>,
-): Result<string> {
-	const parsed = parseSkillFrontmatterBlock(text);
-	if (!parsed.ok)
-		return {
-			ok: false,
-			error: { ...parsed.error, message: `${pathLabel} ${parsed.error.message}` },
-		};
-
-	const split = splitMarkdownFrontmatter(text);
-	if (split.type !== "found")
-		return err({
-			code: "frontmatter_invalid_bounds",
-			message: `${pathLabel} invalid frontmatter bounds`,
-		});
-
-	const lines = [...split.block.linesWithEndings];
-	const nameIndex = lines.findIndex(
-		(line, index) =>
-			index > 0 && index < split.block.closingIndex && isSkillFrontmatterTopLevelKey(line, "name"),
-	);
-	if (nameIndex === -1)
-		return err({
-			code: "frontmatter_missing_name",
-			message: `${pathLabel} missing name field in frontmatter`,
-		});
-
-	const managedKeys = Object.keys(desired);
-	const kept = lines.filter(
-		(line, index) =>
-			index <= 0 ||
-			index >= split.block.closingIndex ||
-			!managedKeys.some((key) => isSkillFrontmatterTopLevelKey(line, key)),
-	);
-	const keptNameIndex = kept.findIndex(
-		(line, index) => index > 0 && isSkillFrontmatterTopLevelKey(line, "name"),
-	);
-	const additions = managedKeys.flatMap((key) => {
-		const value = desired[key];
-		return value === undefined ? [] : [`${key}: ${value}${split.block.lineEnding}`];
-	});
-	kept.splice(keptNameIndex + 1, 0, ...additions);
-	return { ok: true, value: kept.join("") };
-}