my-pi 0.0.2 → 0.0.4

package/src/skills/importer.test.ts

@@ -0,0 +1,301 @@
+import { randomBytes } from 'node:crypto';
+import {
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+	afterEach,
+	beforeEach,
+	describe,
+	expect,
+	it,
+	vi,
+} from 'vitest';
+
+function tmp_test_dir(): string {
+	const dir = join(
+		tmpdir(),
+		`my-pi-skills-test-${randomBytes(4).toString('hex')}`,
+	);
+	mkdirSync(dir, { recursive: true });
+	return dir;
+}
+
+function write_skill(
+	base_dir: string,
+	name: string,
+	description: string,
+): void {
+	mkdirSync(base_dir, { recursive: true });
+	writeFileSync(
+		join(base_dir, 'SKILL.md'),
+		`---\nname: ${name}\ndescription: ${description}\n---\n\n# ${name}\n`,
+	);
+}
+
+function write_plugin_registry(
+	home_dir: string,
+	plugins: Record<
+		string,
+		{
+			installPath: string;
+			version: string;
+			gitCommitSha?: string;
+		}
+	>,
+): void {
+	const plugins_dir = join(home_dir, '.claude', 'plugins');
+	mkdirSync(plugins_dir, { recursive: true });
+	writeFileSync(
+		join(plugins_dir, 'installed_plugins.json'),
+		JSON.stringify(
+			{
+				version: 2,
+				plugins: Object.fromEntries(
+					Object.entries(plugins).map(([key, value]) => [
+						key,
+						[
+							{
+								scope: 'user',
+								installPath: value.installPath,
+								version: value.version,
+								...(value.gitCommitSha
+									? { gitCommitSha: value.gitCommitSha }
+									: {}),
+							},
+						],
+					]),
+				),
+			},
+			null,
+			2,
+		),
+	);
+}
+
+describe('skills importing and syncing', () => {
+	let home_dir: string;
+	let original_home: string | undefined;
+	let original_xdg: string | undefined;
+
+	beforeEach(() => {
+		home_dir = tmp_test_dir();
+		original_home = process.env.HOME;
+		original_xdg = process.env.XDG_CONFIG_HOME;
+		process.env.HOME = home_dir;
+		process.env.XDG_CONFIG_HOME = join(home_dir, '.config');
+		vi.resetModules();
+	});
+
+	afterEach(() => {
+		if (original_home === undefined) {
+			delete process.env.HOME;
+		} else {
+			process.env.HOME = original_home;
+		}
+		if (original_xdg === undefined) {
+			delete process.env.XDG_CONFIG_HOME;
+		} else {
+			process.env.XDG_CONFIG_HOME = original_xdg;
+		}
+		rmSync(home_dir, { recursive: true, force: true });
+	});
+
+	it('imports an external plugin skill into pi-native storage with tracking metadata', async () => {
+		const install_path = join(
+			home_dir,
+			'plugin-cache',
+			'frontend-design',
+			'1.0.0',
+		);
+		write_skill(
+			join(install_path, 'skills', 'frontend-design'),
+			'frontend-design',
+			'Build beautiful interfaces',
+		);
+		write_plugin_registry(home_dir, {
+			'frontend-design@claude-plugins-official': {
+				installPath: install_path,
+				version: '1.0.0',
+				gitCommitSha: 'abc123def456',
+			},
+		});
+
+		const { scan_importable_skills, IMPORT_METADATA_FILE } =
+			await import('./scanner.js');
+		const { import_external_skill } = await import('./importer.js');
+
+		const skill = scan_importable_skills().find(
+			(skill) => skill.name === 'frontend-design',
+		);
+		expect(skill).toBeDefined();
+		expect(skill?.kind).toBe('external');
+
+		const result = import_external_skill(skill!);
+		expect(result.skillDir).toBe(
+			join(home_dir, '.pi', 'agent', 'skills', 'frontend-design'),
+		);
+		expect(existsSync(join(result.skillDir, 'SKILL.md'))).toBe(true);
+
+		const metadata = JSON.parse(
+			readFileSync(
+				join(result.skillDir, IMPORT_METADATA_FILE),
+				'utf-8',
+			),
+		) as Record<string, string>;
+		expect(metadata.source).toBe(
+			'plugin:frontend-design@claude-plugins-official',
+		);
+		expect(metadata.upstream_skill_path).toContain(
+			'skills/frontend-design/SKILL.md',
+		);
+		expect(metadata.upstream_version).toBe('1.0.0');
+		expect(metadata.upstream_git_commit_sha).toBe('abc123def456');
+		expect(metadata.imported_hash).toBeTruthy();
+		expect(metadata.upstream_hash).toBeTruthy();
+	});
+
+	it('syncs an imported skill when the upstream source changes', async () => {
+		const install_path = join(
+			home_dir,
+			'plugin-cache',
+			'toolkit-skills',
+			'0.0.1',
+		);
+		const upstream_dir = join(install_path, 'skills', 'github-prs');
+		write_skill(
+			upstream_dir,
+			'github-prs',
+			'Find and manage pull requests',
+		);
+		write_plugin_registry(home_dir, {
+			'toolkit-skills@claude-code-toolkit': {
+				installPath: install_path,
+				version: '0.0.1',
+			},
+		});
+
+		const scanner = await import('./scanner.js');
+		const importer = await import('./importer.js');
+
+		const external = scanner
+			.scan_importable_skills()
+			.find((skill) => skill.name === 'github-prs');
+		importer.import_external_skill(external!);
+
+		writeFileSync(
+			join(upstream_dir, 'helper.txt'),
+			'new upstream helper content',
+		);
+
+		const managed = scanner
+			.scan_managed_skills()
+			.find((skill) => skill.name === 'github-prs');
+		const result = importer.sync_imported_skill(managed!);
+
+		expect(result.changed).toBe(true);
+		expect(
+			readFileSync(join(result.skillDir, 'helper.txt'), 'utf-8'),
+		).toBe('new upstream helper content');
+	});
+
+	it('refuses to sync when the managed copy has local changes', async () => {
+		const install_path = join(
+			home_dir,
+			'plugin-cache',
+			'linear',
+			'2.0.0',
+		);
+		const upstream_dir = join(install_path, 'skills', 'linear');
+		write_skill(upstream_dir, 'linear', 'Work with Linear issues');
+		write_plugin_registry(home_dir, {
+			'linear@vendor': {
+				installPath: install_path,
+				version: '2.0.0',
+			},
+		});
+
+		const scanner = await import('./scanner.js');
+		const importer = await import('./importer.js');
+
+		const external = scanner
+			.scan_importable_skills()
+			.find((skill) => skill.name === 'linear');
+		const imported = importer.import_external_skill(external!);
+
+		writeFileSync(
+			join(imported.skillDir, 'notes.md'),
+			'local customization that should block sync',
+		);
+		writeFileSync(
+			join(upstream_dir, 'notes.md'),
+			'upstream changed too',
+		);
+
+		const managed = scanner
+			.scan_managed_skills()
+			.find((skill) => skill.name === 'linear');
+		expect(() => importer.sync_imported_skill(managed!)).toThrow(
+			/local changes detected/i,
+		);
+	});
+
+	it('manager separates managed and importable skills and enables imported skills', async () => {
+		write_skill(
+			join(home_dir, '.claude', 'skills', 'github-prs'),
+			'github-prs',
+			'Local managed GitHub PR skill',
+		);
+
+		const install_path = join(
+			home_dir,
+			'plugin-cache',
+			'frontend-design',
+			'3.0.0',
+		);
+		write_skill(
+			join(install_path, 'skills', 'frontend-design'),
+			'frontend-design',
+			'Plugin frontend design skill',
+		);
+		write_plugin_registry(home_dir, {
+			'frontend-design@claude-plugins-official': {
+				installPath: install_path,
+				version: '3.0.0',
+			},
+		});
+
+		const { create_skills_manager } = await import('./manager.js');
+		const mgr = create_skills_manager();
+
+		expect(mgr.discover().map((skill) => skill.name)).toEqual([
+			'github-prs',
+		]);
+		expect(
+			mgr.discover_importable().map((skill) => skill.name),
+		).toEqual(['frontend-design']);
+
+		const imported = mgr.import_skill('frontend-design');
+		expect(imported.key).toBe('frontend-design@pi-native');
+
+		const managed_names = mgr
+			.discover()
+			.map((skill) => skill.name)
+			.sort();
+		expect(managed_names).toEqual(['frontend-design', 'github-prs']);
+		expect(mgr.get_enabled_skill_paths()).toContain(
+			imported.skillDir,
+		);
+		expect(
+			mgr.is_enabled_by_skill(
+				'frontend-design',
+				join(imported.skillDir, 'SKILL.md'),
+			),
+		).toBe(true);
+	});
+});

package/src/skills/importer.ts

@@ -0,0 +1,221 @@
+import { createHash } from 'node:crypto';
+import {
+	cpSync,
+	existsSync,
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	rmSync,
+	statSync,
+	writeFileSync,
+} from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, relative, resolve } from 'node:path';
+import {
+	IMPORT_METADATA_FILE,
+	type DiscoveredSkill,
+	type ImportedSkillMetadata,
+} from './scanner.js';
+
+const IMPORT_METADATA_VERSION = 1;
+
+function get_managed_skills_dir(): string {
+	return join(homedir(), '.pi', 'agent', 'skills');
+}
+
+function ensure_dir(path: string): void {
+	mkdirSync(path, { recursive: true, mode: 0o700 });
+}
+
+function list_files_recursively(dir: string): string[] {
+	const files: string[] = [];
+
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		const full_path = join(dir, entry.name);
+		if (entry.name === IMPORT_METADATA_FILE) continue;
+		if (entry.isDirectory()) {
+			files.push(...list_files_recursively(full_path));
+			continue;
+		}
+		if (entry.isFile()) {
+			files.push(full_path);
+		}
+	}
+
+	return files.sort((a, b) => a.localeCompare(b));
+}
+
+function hash_directory(dir: string): string {
+	const hash = createHash('sha256');
+	for (const file of list_files_recursively(dir)) {
+		hash.update(relative(dir, file));
+		hash.update('\0');
+		hash.update(readFileSync(file));
+		hash.update('\0');
+	}
+	return hash.digest('hex');
+}
+
+function read_metadata(
+	base_dir: string,
+): ImportedSkillMetadata | undefined {
+	const path = join(base_dir, IMPORT_METADATA_FILE);
+	if (!existsSync(path)) return undefined;
+
+	try {
+		return JSON.parse(
+			readFileSync(path, 'utf-8'),
+		) as ImportedSkillMetadata;
+	} catch {
+		return undefined;
+	}
+}
+
+function write_metadata(
+	base_dir: string,
+	metadata: ImportedSkillMetadata,
+): void {
+	writeFileSync(
+		join(base_dir, IMPORT_METADATA_FILE),
+		JSON.stringify(metadata, null, '\t') + '\n',
+		{ mode: 0o600 },
+	);
+}
+
+function replace_directory(
+	source_dir: string,
+	dest_dir: string,
+): void {
+	const parent_dir = dirname(dest_dir);
+	ensure_dir(parent_dir);
+	const tmp_dir = join(
+		parent_dir,
+		`.${resolve(dest_dir).split('/').pop()}.tmp-${Date.now()}`,
+	);
+
+	rmSync(tmp_dir, { recursive: true, force: true });
+	cpSync(source_dir, tmp_dir, {
+		recursive: true,
+		preserveTimestamps: true,
+		verbatimSymlinks: false,
+	});
+	rmSync(dest_dir, { recursive: true, force: true });
+	cpSync(tmp_dir, dest_dir, {
+		recursive: true,
+		preserveTimestamps: true,
+		verbatimSymlinks: false,
+	});
+	rmSync(tmp_dir, { recursive: true, force: true });
+}
+
+export interface ImportSkillResult {
+	skillDir: string;
+	metadata: ImportedSkillMetadata;
+}
+
+export function import_external_skill(
+	skill: DiscoveredSkill,
+): ImportSkillResult {
+	if (skill.kind !== 'external') {
+		throw new Error(`Skill ${skill.name} is not importable`);
+	}
+
+	const managed_root = get_managed_skills_dir();
+	ensure_dir(managed_root);
+
+	const skill_dir = join(managed_root, skill.name);
+	const existing = existsSync(skill_dir);
+	if (existing) {
+		const existing_stat = statSync(skill_dir);
+		if (!existing_stat.isDirectory()) {
+			throw new Error(`${skill_dir} exists and is not a directory`);
+		}
+
+		const existing_metadata = read_metadata(skill_dir);
+		if (!existing_metadata) {
+			throw new Error(
+				`Refusing to overwrite existing unmanaged skill at ${skill_dir}`,
+			);
+		}
+	}
+
+	replace_directory(skill.baseDir, skill_dir);
+
+	const upstream_hash = hash_directory(skill.baseDir);
+	const imported_hash = hash_directory(skill_dir);
+	const now = new Date().toISOString();
+	const metadata: ImportedSkillMetadata = {
+		version: IMPORT_METADATA_VERSION,
+		source: skill.source,
+		upstream_skill_path: skill.skillPath,
+		upstream_base_dir: skill.baseDir,
+		upstream_install_path: skill.plugin?.installPath,
+		upstream_version: skill.plugin?.version,
+		upstream_git_commit_sha: skill.plugin?.gitCommitSha,
+		imported_at: now,
+		last_synced_at: now,
+		imported_hash,
+		upstream_hash,
+	};
+
+	write_metadata(skill_dir, metadata);
+	return {
+		skillDir: skill_dir,
+		metadata,
+	};
+}
+
+export interface SyncSkillResult {
+	skillDir: string;
+	metadata: ImportedSkillMetadata;
+	changed: boolean;
+}
+
+export function sync_imported_skill(
+	skill: DiscoveredSkill,
+): SyncSkillResult {
+	if (skill.kind !== 'managed' || !skill.import_meta) {
+		throw new Error(
+			`Skill ${skill.name} is not managed by my-pi sync`,
+		);
+	}
+
+	const metadata = skill.import_meta;
+	if (!existsSync(metadata.upstream_base_dir)) {
+		throw new Error(
+			`Upstream source no longer exists: ${metadata.upstream_base_dir}`,
+		);
+	}
+
+	const current_hash = hash_directory(skill.baseDir);
+	if (current_hash !== metadata.imported_hash) {
+		throw new Error(
+			`Refusing to sync ${skill.name}; local changes detected in ${skill.baseDir}`,
+		);
+	}
+
+	const upstream_hash = hash_directory(metadata.upstream_base_dir);
+	if (upstream_hash === metadata.upstream_hash) {
+		return {
+			skillDir: skill.baseDir,
+			metadata,
+			changed: false,
+		};
+	}
+
+	replace_directory(metadata.upstream_base_dir, skill.baseDir);
+	const imported_hash = hash_directory(skill.baseDir);
+	const updated: ImportedSkillMetadata = {
+		...metadata,
+		last_synced_at: new Date().toISOString(),
+		imported_hash,
+		upstream_hash,
+	};
+	write_metadata(skill.baseDir, updated);
+
+	return {
+		skillDir: skill.baseDir,
+		metadata: updated,
+		changed: true,
+	};
+}