@garthub/gart-npm 0.1.1

package/src/commands/resolve.js

@@ -0,0 +1,108 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const {resolveSkillArtifacts} = require('../resolve-artifacts');
+const {synchronizeManagedSkills} = require('../managed-skills');
+
+async function runResolve(context) {
+	const {config, args, extractor} = context;
+	const isPostInstall = args.includes('--postinstall');
+	const dependencies = [
+		...config.resolution.dependencies.skills,
+		...config.resolution.dependencies.exposedSkills,
+	];
+
+	if (dependencies.length === 0) {
+		if (!isPostInstall) {
+			console.log('[gart] No skill dependencies configured.');
+		}
+		return;
+	}
+
+	fs.mkdirSync(config.managedSkillsDir, {recursive: true});
+	fs.mkdirSync(config.buildDir, {recursive: true});
+
+	const resolution = await resolveSkillArtifacts(config);
+	const indexPath = path.join(config.managedSkillsDir, 'gart.json');
+	const index = {
+		version: 1,
+		generatedAt: new Date().toISOString(),
+		status: resolution.unresolved.length === 0 ? 'artifactsResolved' : 'artifactLookupFailed',
+		managedDir: config.managedSkillsDir,
+		repositories: config.resolution.repositories,
+		dependencies: {
+			skills: config.resolution.dependencies.skills,
+			exposedSkills: config.resolution.dependencies.exposedSkills,
+		},
+		directDependencies: resolution.directDependencies,
+		transitiveDependencies: resolution.transitiveDependencies,
+		resolvedArtifacts: resolution.resolvedArtifacts,
+		unresolved: resolution.unresolved,
+		note: 'Artifact lookup and remote download are implemented. Checksum verification, unpacking, and reconciliation are not implemented yet.',
+	};
+
+	if (resolution.unresolved.length > 0) {
+		fs.writeFileSync(indexPath, JSON.stringify(index, null, 2));
+		throw new Error(formatUnresolvedMessage(resolution.unresolved));
+	}
+
+	try {
+		const synchronization = await synchronizeManagedSkills(config, resolution.resolvedArtifacts, {
+			extractor,
+		});
+		index.status = 'skillsReconciled';
+		index.resolvedArtifacts = synchronization.resolvedArtifacts;
+		index.managedFiles = synchronization.managedFiles;
+		index.removedFiles = synchronization.removedFiles;
+		index.writtenFiles = synchronization.writtenFiles;
+		index.note = 'Artifact lookup, download, unpacking, and managed skill reconciliation are implemented. Checksum verification is still pending.';
+		fs.writeFileSync(indexPath, JSON.stringify(index, null, 2));
+	} catch (error) {
+		index.status = 'reconciliationFailed';
+		index.reconciliationError = error.message;
+		index.note = 'Artifact lookup and download succeeded, but managed skill reconciliation failed.';
+		fs.writeFileSync(indexPath, JSON.stringify(index, null, 2));
+		throw error;
+	}
+
+	console.log(`[gart] Resolved ${resolution.resolvedArtifacts.length} skill artifact(s).`);
+	console.log(`[gart] Extracted managed skills into ${config.managedSkillsDir}.`);
+	console.log(`[gart] Resolution index written to ${indexPath}.`);
+}
+
+function formatUnresolvedMessage(unresolvedEntries) {
+	const lines = ['Failed to resolve one or more skill artifacts:'];
+
+	for (const entry of unresolvedEntries) {
+		lines.push(`- ${entry.dependency.coordinates}: ${entry.reason}`);
+
+		for (const attempt of entry.attempts) {
+			const details = [];
+
+			if (attempt.phase) {
+				details.push(`phase=${attempt.phase}`);
+			}
+
+			if (typeof attempt.statusCode === 'number') {
+				details.push(`HTTP ${attempt.statusCode}`);
+			}
+
+			if (attempt.source) {
+				details.push(`source=${attempt.source}`);
+			}
+
+			if (attempt.error) {
+				details.push(`error=${attempt.error}`);
+			}
+
+			const suffix = details.length > 0 ? ` [${details.join(', ')}]` : '';
+			lines.push(`  * ${attempt.repositoryType} (${attempt.repositoryId}) -> ${attempt.location}${suffix}`);
+		}
+	}
+
+	return lines.join('\n');
+}
+
+module.exports = {
+	runResolve,
+	formatUnresolvedMessage,
+};

package/src/config.js

@@ -0,0 +1,186 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const {defaultMavenLocalRepository, normalizeRepository} = require('./maven');
+
+const DEFAULT_CONFIG = {
+	srcDirs: ['skills'],
+	managedSkillsDir: '.agents/skills',
+	buildDir: '.gart',
+	resolution: {
+		repositories: [],
+		dependencies: {
+			skills: [],
+			exposedSkills: [],
+		},
+	},
+	publishing: {
+		repository: null,
+	},
+};
+
+function loadConfig(cwd) {
+	const loaded = loadRawConfig(cwd);
+	return normalizeConfig(loaded, cwd);
+}
+
+function loadRawConfig(cwd) {
+	const configFiles = [
+		'gart.config.js',
+		'gart.config.cjs',
+		'gart.config.json',
+	];
+
+	for (const fileName of configFiles) {
+		const filePath = path.join(cwd, fileName);
+
+		if (!fs.existsSync(filePath)) {
+			continue;
+		}
+
+		if (fileName.endsWith('.json')) {
+			return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+		}
+
+		delete require.cache[require.resolve(filePath)];
+		const loaded = require(filePath);
+		return loaded && loaded.default ? loaded.default : loaded;
+	}
+
+	const packageJsonPath = path.join(cwd, 'package.json');
+	if (!fs.existsSync(packageJsonPath)) {
+		return {};
+	}
+
+	const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+	return packageJson.gart || {};
+}
+
+function normalizeConfig(
+	rawConfig,
+	cwd,
+) {
+	const config = {
+		...DEFAULT_CONFIG,
+		...rawConfig,
+		resolution: {
+			...DEFAULT_CONFIG.resolution,
+			...(rawConfig.resolution || {}),
+			dependencies: {
+				...DEFAULT_CONFIG.resolution.dependencies,
+				...((rawConfig.resolution || {}).dependencies || {}),
+			},
+		},
+		publishing: {
+			...DEFAULT_CONFIG.publishing,
+			...(rawConfig.publishing || {}),
+		},
+	};
+
+	const buildDir = path.resolve(cwd, config.buildDir);
+	const cacheDir = rawConfig.cacheDir ? path.resolve(cwd, rawConfig.cacheDir) : path.join(buildDir, 'cache');
+
+	return {
+		...config,
+		cwd,
+		srcDirs: toArray(config.srcDirs),
+		managedSkillsDir: path.resolve(cwd, config.managedSkillsDir),
+		buildDir,
+		cacheDir,
+		resolution: {
+			...config.resolution,
+			repositories: normalizeRepositories(config.resolution.repositories, cwd),
+			dependencies: {
+				skills: normalizeCoordinates(config.resolution.dependencies.skills),
+				exposedSkills: normalizeCoordinates(config.resolution.dependencies.exposedSkills),
+			},
+		},
+		publishing: {
+			...config.publishing,
+			coordinates: normalizeOptionalCoordinates(config.publishing.coordinates, 'Publishing coordinates'),
+			groupId: normalizeOptionalString(config.publishing.groupId, 'Publishing groupId'),
+			artifactId: normalizeOptionalString(config.publishing.artifactId, 'Publishing artifactId'),
+			version: normalizeOptionalString(config.publishing.version, 'Publishing version'),
+			repository: config.publishing.repository
+				? normalizeRepository(config.publishing.repository, cwd, 'publishing')
+				: null,
+		},
+	};
+}
+
+function normalizeRepositories(
+	value,
+	cwd,
+) {
+	return toArray(value).map((
+		repository,
+		index,
+	) => normalizeRepository(repository, cwd, `resolution-${index + 1}`));
+}
+
+function toArray(value) {
+	if (!value) {
+		return [];
+	}
+
+	return Array.isArray(value) ? value : [value];
+}
+
+function normalizeCoordinates(value) {
+	return toArray(value).map((entry) => {
+		if (typeof entry !== 'string') {
+			throw new Error('Skill coordinates must be strings in the form group:artifact:version');
+		}
+
+		const parts = entry.split(':');
+		if (parts.length !== 3 || parts.some((part) => !part)) {
+			throw new Error(`Invalid skill coordinates: ${entry}`);
+		}
+
+		return entry;
+	});
+}
+
+function normalizeOptionalCoordinates(
+	value,
+	label,
+) {
+	if (value == null) {
+		return null;
+	}
+
+	if (typeof value !== 'string') {
+		throw new Error(`${label} must be a string in the form group:artifact:version`);
+	}
+
+	const parts = value.split(':');
+	if (parts.length !== 3 || parts.some((part) => !part)) {
+		throw new Error(`${label} must be a string in the form group:artifact:version`);
+	}
+
+	return value;
+}
+
+function normalizeOptionalString(
+	value,
+	label,
+) {
+	if (value == null) {
+		return null;
+	}
+
+	if (typeof value !== 'string' || value.trim().length === 0) {
+		throw new Error(`${label} must be a non-empty string`);
+	}
+
+	return value;
+}
+
+module.exports = {
+	loadConfig,
+	loadRawConfig,
+	normalizeConfig,
+	normalizeCoordinates,
+	normalizeOptionalCoordinates,
+	DEFAULT_CONFIG,
+	DEFAULT_MAVEN_LOCAL_REPOSITORY: defaultMavenLocalRepository(),
+};

package/src/hash.js

@@ -0,0 +1,47 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+function computeFileSha256(filePath) {
+	const hash = crypto.createHash('sha256');
+	const content = fs.readFileSync(filePath);
+	hash.update(content);
+	return hash.digest('hex');
+}
+
+function maybeComputeFileSha256(filePath) {
+	if (!filePath || !fs.existsSync(filePath)) {
+		return null;
+	}
+
+	return computeFileSha256(filePath);
+}
+
+function listFilesRecursively(rootDir) {
+	const files = [];
+
+	if (!fs.existsSync(rootDir)) {
+		return files;
+	}
+
+	for (const entry of fs.readdirSync(rootDir, {withFileTypes: true})) {
+		const absolutePath = path.join(rootDir, entry.name);
+
+		if (entry.isDirectory()) {
+			files.push(...listFilesRecursively(absolutePath));
+			continue;
+		}
+
+		if (entry.isFile()) {
+			files.push(absolutePath);
+		}
+	}
+
+	return files;
+}
+
+module.exports = {
+	computeFileSha256,
+	maybeComputeFileSha256,
+	listFilesRecursively,
+};

package/src/http.js

@@ -0,0 +1,146 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const http = require('node:http');
+const https = require('node:https');
+
+function downloadToFile(
+	url,
+	destinationPath,
+	options = {},
+) {
+	return requestToFile(url, destinationPath, options, 0);
+}
+
+function uploadFile(
+	url,
+	sourcePath,
+	options = {},
+) {
+	return uploadBuffer(url, fs.readFileSync(sourcePath), options);
+}
+
+function uploadText(
+	url,
+	content,
+	options = {},
+) {
+	return uploadBuffer(url, Buffer.from(content, 'utf8'), options);
+}
+
+function requestToFile(
+	url,
+	destinationPath,
+	options,
+	redirectCount,
+) {
+	return new Promise((
+		resolve,
+		reject,
+	) => {
+		const transport = url.startsWith('https://') ? https : http;
+		const request = transport.get(url, {headers: options.headers || {}}, (response) => {
+			const statusCode = response.statusCode || 0;
+
+			if (isRedirect(statusCode) && response.headers.location) {
+				if (redirectCount >= 5) {
+					response.resume();
+					resolve({ok: false, statusCode, url, note: 'Too many redirects.'});
+					return;
+				}
+
+				const redirectUrl = new URL(response.headers.location, url).toString();
+				response.resume();
+				resolve(requestToFile(redirectUrl, destinationPath, options, redirectCount + 1));
+				return;
+			}
+
+			if (statusCode !== 200) {
+				response.resume();
+				resolve({ok: false, statusCode, url});
+				return;
+			}
+
+			fs.mkdirSync(path.dirname(destinationPath), {recursive: true});
+			const output = fs.createWriteStream(destinationPath);
+
+			response.pipe(output);
+
+			output.on('finish', () => {
+				output.close(() => {
+					resolve({ok: true, statusCode, url, destinationPath});
+				});
+			});
+
+			output.on('error', (error) => {
+				output.destroy();
+				safeDelete(destinationPath);
+				reject(error);
+			});
+		});
+
+		request.on('error', (error) => {
+			safeDelete(destinationPath);
+			reject(error);
+		});
+	});
+}
+
+function safeDelete(filePath) {
+	try {
+		if (fs.existsSync(filePath)) {
+			fs.unlinkSync(filePath);
+		}
+	} catch (error) {
+		// Ignore cleanup failures for temporary download files.
+	}
+}
+
+function isRedirect(statusCode) {
+	return [301, 302, 303, 307, 308].includes(statusCode);
+}
+
+function uploadBuffer(
+	url,
+	body,
+	options = {},
+) {
+	return new Promise((
+		resolve,
+		reject,
+	) => {
+		const transport = url.startsWith('https://') ? https : http;
+		const request = transport.request(url, {
+			method: options.method || 'PUT',
+			headers: {
+				'Content-Length': body.length,
+				...(options.headers || {}),
+			},
+		}, (response) => {
+			const chunks = [];
+
+			response.on('data', (chunk) => {
+				chunks.push(chunk);
+			});
+
+			response.on('end', () => {
+				const statusCode = response.statusCode || 0;
+				resolve({
+					ok: [200, 201, 202, 204].includes(statusCode),
+					statusCode,
+					url,
+					body: Buffer.concat(chunks).toString('utf8'),
+				});
+			});
+		});
+
+		request.on('error', reject);
+		request.write(body);
+		request.end();
+	});
+}
+
+module.exports = {
+	downloadToFile,
+	uploadFile,
+	uploadText,
+};