@ottocode/server 0.1.265 → 0.1.266

package/src/routes/skills/service.ts

@@ -0,0 +1,221 @@
+import type { Context } from 'hono';
+import {
+	discoverSkillFiles,
+	discoverSkills,
+	filterDiscoveredSkills,
+	findGitRoot,
+	loadConfig,
+	loadSkill,
+	loadSkillFile,
+	logger,
+	parseSkillFile,
+	validateSkillName,
+	writeSkillSettings,
+} from '@ottocode/sdk';
+import { serializeError } from '../../runtime/errors/api-error.ts';
+
+function dedupeSkillsByName<T extends { name: string }>(skills: T[]): T[] {
+	const seen = new Set<string>();
+	return skills.filter((skill) => {
+		const key = skill.name.trim();
+		if (!key || seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+
+function sortSkillsByName<T extends { name: string }>(skills: T[]): T[] {
+	return [...skills].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function mapSkillsWithEnabled(
+	discovered: Array<{
+		name: string;
+		description: string;
+		scope: string;
+		path: string;
+	}>,
+	cfg: Awaited<ReturnType<typeof loadConfig>>,
+) {
+	return discovered.map((skill) => ({
+		name: skill.name,
+		description: skill.description,
+		scope: skill.scope,
+		path: skill.path,
+		enabled: cfg.skills?.items?.[skill.name]?.enabled !== false,
+	}));
+}
+
+async function loadProjectSkills(projectRoot: string) {
+	const cfg = await loadConfig(projectRoot);
+	const repoRoot = (await findGitRoot(projectRoot)) ?? projectRoot;
+	const discovered = sortSkillsByName(
+		dedupeSkillsByName(await discoverSkills(projectRoot, repoRoot)),
+	);
+	const filtered = sortSkillsByName(
+		filterDiscoveredSkills(discovered, cfg.skills),
+	);
+	return { cfg, discovered, filtered };
+}
+
+async function ensureSkillsDiscovered(projectRoot: string): Promise<void> {
+	const repoRoot = (await findGitRoot(projectRoot)) ?? projectRoot;
+	await discoverSkills(projectRoot, repoRoot);
+}
+
+function projectRootFromQuery(c: Context): string {
+	return c.req.query('project') || process.cwd();
+}
+
+function jsonError(c: Context, message: string, error: unknown) {
+	logger.error(message, error);
+	const errorResponse = serializeError(error);
+	return c.json(errorResponse, (errorResponse.error.status || 500) as 500);
+}
+
+export async function listSkills(c: Context) {
+	try {
+		const projectRoot = projectRootFromQuery(c);
+		const cfg = await loadConfig(projectRoot);
+		const repoRoot = (await findGitRoot(projectRoot)) ?? projectRoot;
+		const discovered = sortSkillsByName(
+			await discoverSkills(projectRoot, repoRoot),
+		);
+		const filtered = filterDiscoveredSkills(discovered, cfg.skills);
+		const unique = sortSkillsByName(dedupeSkillsByName(filtered));
+		return c.json({
+			skills: mapSkillsWithEnabled(unique, cfg),
+		});
+	} catch (error) {
+		return jsonError(c, 'Failed to list skills', error);
+	}
+}
+
+export async function getSkillsConfig(c: Context) {
+	try {
+		const { cfg, discovered, filtered } = await loadProjectSkills(
+			projectRootFromQuery(c),
+		);
+		return c.json({
+			enabled: cfg.skills?.enabled !== false,
+			totalCount: discovered.length,
+			enabledCount: filtered.length,
+			items: mapSkillsWithEnabled(discovered, cfg),
+		});
+	} catch (error) {
+		return jsonError(c, 'Failed to get skills config', error);
+	}
+}
+
+export async function updateSkillsConfig(c: Context) {
+	try {
+		const projectRoot = projectRootFromQuery(c);
+		const body = await c.req.json<{
+			enabled?: boolean;
+			items?: Record<string, { enabled?: boolean }>;
+		}>();
+		await writeSkillSettings(
+			'global',
+			{
+				...(body.enabled !== undefined ? { enabled: body.enabled } : {}),
+				...(body.items ? { items: body.items } : {}),
+			},
+			projectRoot,
+		);
+
+		const { cfg, discovered, filtered } = await loadProjectSkills(projectRoot);
+		return c.json({
+			success: true,
+			enabled: cfg.skills?.enabled !== false,
+			totalCount: discovered.length,
+			enabledCount: filtered.length,
+			items: mapSkillsWithEnabled(discovered, cfg),
+		});
+	} catch (error) {
+		return jsonError(c, 'Failed to update skills config', error);
+	}
+}
+
+export async function getSkill(c: Context) {
+	try {
+		const name = c.req.param('name');
+		await ensureSkillsDiscovered(projectRootFromQuery(c));
+
+		const skill = await loadSkill(name);
+		if (!skill) {
+			return c.json({ error: `Skill '${name}' not found` }, 404);
+		}
+
+		return c.json({
+			name: skill.metadata.name,
+			description: skill.metadata.description,
+			license: skill.metadata.license ?? null,
+			compatibility: skill.metadata.compatibility ?? null,
+			metadata: skill.metadata.metadata ?? null,
+			allowedTools: skill.metadata.allowedTools ?? null,
+			path: skill.path,
+			scope: skill.scope,
+			content: skill.content,
+		});
+	} catch (error) {
+		return jsonError(c, 'Failed to load skill', error);
+	}
+}
+
+export async function listSkillFiles(c: Context) {
+	try {
+		const name = c.req.param('name');
+		await ensureSkillsDiscovered(projectRootFromQuery(c));
+		const files = await discoverSkillFiles(name);
+		return c.json({ files });
+	} catch (error) {
+		return jsonError(c, 'Failed to list skill files', error);
+	}
+}
+
+export async function getSkillFile(c: Context) {
+	try {
+		const name = c.req.param('name');
+		const filePath = c.req.path.replace(`/v1/skills/${name}/files/`, '');
+		await ensureSkillsDiscovered(projectRootFromQuery(c));
+
+		const result = await loadSkillFile(name, filePath);
+		if (!result) {
+			return c.json(
+				{ error: `File '${filePath}' not found in skill '${name}'` },
+				404,
+			);
+		}
+		return c.json({ content: result.content, path: result.resolvedPath });
+	} catch (error) {
+		return jsonError(c, 'Failed to load skill file', error);
+	}
+}
+
+export async function validateSkill(c: Context) {
+	try {
+		const body = await c.req.json<{ content: string; path?: string }>();
+		if (!body.content) {
+			return c.json({ error: 'content is required' }, 400);
+		}
+
+		const skillPath = body.path ?? 'SKILL.md';
+		const skill = parseSkillFile(body.content, skillPath, 'cwd');
+		return c.json({
+			valid: true,
+			name: skill.metadata.name,
+			description: skill.metadata.description,
+			license: skill.metadata.license ?? null,
+		});
+	} catch (error) {
+		return c.json({
+			valid: false,
+			error: (error as Error).message,
+		});
+	}
+}
+
+export function validateSkillNameRoute(c: Context) {
+	const name = c.req.param('name');
+	return c.json({ valid: validateSkillName(name) });
+}

package/src/routes/skills/spec.ts

@@ -0,0 +1,309 @@
+const projectQueryParameter = {
+	in: 'query',
+	name: 'project',
+	required: false,
+	schema: { type: 'string' },
+	description: 'Project root override (defaults to current working directory).',
+};
+
+const skillNamePathParameter = {
+	in: 'path',
+	name: 'name',
+	required: true,
+	schema: { type: 'string' },
+};
+
+const errorResponse = {
+	description: 'Bad Request',
+	content: {
+		'application/json': {
+			schema: {
+				type: 'object',
+				properties: {
+					error: { type: 'string' },
+				},
+				required: ['error'],
+			},
+		},
+	},
+};
+
+const skillListItemSchema = {
+	type: 'object',
+	properties: {
+		name: { type: 'string' },
+		description: { type: 'string' },
+		scope: { type: 'string' },
+		path: { type: 'string' },
+	},
+	required: ['name', 'description', 'scope', 'path'],
+};
+
+const skillConfigItemSchema = {
+	type: 'object',
+	properties: {
+		name: { type: 'string' },
+		description: { type: 'string' },
+		scope: { type: 'string' },
+		path: { type: 'string' },
+		enabled: { type: 'boolean' },
+	},
+	required: ['name', 'description', 'scope', 'path', 'enabled'],
+};
+
+const skillConfigSchema = {
+	type: 'object',
+	properties: {
+		enabled: { type: 'boolean' },
+		totalCount: { type: 'number' },
+		enabledCount: { type: 'number' },
+		items: {
+			type: 'array',
+			items: skillConfigItemSchema,
+		},
+	},
+	required: ['enabled', 'totalCount', 'enabledCount', 'items'],
+};
+
+const skillConfigUpdateSchema = {
+	type: 'object',
+	properties: {
+		enabled: { type: 'boolean' },
+		items: {
+			type: 'object',
+			additionalProperties: {
+				type: 'object',
+				properties: {
+					enabled: { type: 'boolean' },
+				},
+			},
+		},
+	},
+};
+
+const skillConfigUpdateResponseSchema = {
+	type: 'object',
+	properties: {
+		success: { type: 'boolean' },
+		...skillConfigSchema.properties,
+	},
+	required: ['success', 'enabled', 'totalCount', 'enabledCount', 'items'],
+};
+
+const skillDetailSchema = {
+	type: 'object',
+	properties: {
+		name: { type: 'string' },
+		description: { type: 'string' },
+		license: { type: 'string', nullable: true },
+		compatibility: { type: 'string', nullable: true },
+		metadata: { type: 'object', nullable: true },
+		allowedTools: {
+			type: 'array',
+			items: { type: 'string' },
+			nullable: true,
+		},
+		path: { type: 'string' },
+		scope: { type: 'string' },
+		content: { type: 'string' },
+	},
+	required: ['name', 'description', 'path', 'scope', 'content'],
+};
+
+const skillFileListSchema = {
+	type: 'object',
+	properties: {
+		files: {
+			type: 'array',
+			items: {
+				type: 'object',
+				properties: {
+					relativePath: { type: 'string' },
+					size: { type: 'number' },
+				},
+				required: ['relativePath', 'size'],
+			},
+		},
+	},
+	required: ['files'],
+};
+
+const skillFileSchema = {
+	type: 'object',
+	properties: {
+		content: { type: 'string' },
+		path: { type: 'string' },
+	},
+	required: ['content', 'path'],
+};
+
+const validateSkillRequestSchema = {
+	type: 'object',
+	properties: {
+		content: { type: 'string' },
+		path: { type: 'string' },
+	},
+	required: ['content'],
+};
+
+const validateSkillResponseSchema = {
+	type: 'object',
+	properties: {
+		valid: { type: 'boolean' },
+		name: { type: 'string' },
+		description: { type: 'string' },
+		license: { type: 'string', nullable: true },
+		error: { type: 'string' },
+	},
+	required: ['valid'],
+};
+
+const validateNameResponseSchema = {
+	type: 'object',
+	properties: {
+		valid: { type: 'boolean' },
+	},
+	required: ['valid'],
+};
+
+function jsonResponse(schema: object, description = 'OK') {
+	return {
+		description,
+		content: {
+			'application/json': { schema },
+		},
+	};
+}
+
+export const listSkillsSpec = {
+	method: 'get',
+	path: '/v1/skills',
+	tags: ['config'],
+	operationId: 'listSkills',
+	summary: 'List discovered skills',
+	parameters: [projectQueryParameter],
+	responses: {
+		'200': jsonResponse({
+			type: 'object',
+			properties: {
+				skills: {
+					type: 'array',
+					items: skillListItemSchema,
+				},
+			},
+			required: ['skills'],
+		}),
+		'500': errorResponse,
+	},
+};
+
+export const getSkillsConfigSpec = {
+	method: 'get',
+	path: '/v1/config/skills',
+	tags: ['config'],
+	operationId: 'getSkillsConfig',
+	summary: 'Get skills enable/disable config and counts',
+	parameters: [projectQueryParameter],
+	responses: {
+		'200': jsonResponse(skillConfigSchema),
+		'500': errorResponse,
+	},
+};
+
+export const updateSkillsConfigSpec = {
+	method: 'put',
+	path: '/v1/config/skills',
+	tags: ['config'],
+	operationId: 'updateSkillsConfig',
+	summary: 'Update skills enable/disable config',
+	parameters: [projectQueryParameter],
+	requestBody: {
+		required: true,
+		content: {
+			'application/json': { schema: skillConfigUpdateSchema },
+		},
+	},
+	responses: {
+		'200': jsonResponse(skillConfigUpdateResponseSchema),
+		'500': errorResponse,
+	},
+};
+
+export const getSkillSpec = {
+	method: 'get',
+	path: '/v1/skills/{name}',
+	tags: ['config'],
+	operationId: 'getSkill',
+	summary: 'Get a skill by name',
+	parameters: [skillNamePathParameter, projectQueryParameter],
+	responses: {
+		'200': jsonResponse(skillDetailSchema),
+		'404': errorResponse,
+		'500': errorResponse,
+	},
+};
+
+export const listSkillFilesSpec = {
+	method: 'get',
+	path: '/v1/skills/{name}/files',
+	tags: ['config'],
+	operationId: 'listSkillFiles',
+	summary: 'List files in a skill directory',
+	parameters: [skillNamePathParameter, projectQueryParameter],
+	responses: {
+		'200': jsonResponse(skillFileListSchema),
+		'500': errorResponse,
+	},
+};
+
+export const getSkillFileSpec = {
+	method: 'get',
+	path: '/v1/skills/{name}/files/{filePath}',
+	tags: ['config'],
+	operationId: 'getSkillFile',
+	summary: 'Read a specific file from a skill directory',
+	parameters: [
+		skillNamePathParameter,
+		{
+			in: 'path',
+			name: 'filePath',
+			required: true,
+			schema: { type: 'string' },
+		},
+		projectQueryParameter,
+	],
+	responses: {
+		'200': jsonResponse(skillFileSchema),
+		'404': errorResponse,
+		'500': errorResponse,
+	},
+};
+
+export const validateSkillSpec = {
+	method: 'post',
+	path: '/v1/skills/validate',
+	tags: ['config'],
+	operationId: 'validateSkill',
+	summary: 'Validate a SKILL.md content',
+	requestBody: {
+		required: true,
+		content: {
+			'application/json': { schema: validateSkillRequestSchema },
+		},
+	},
+	responses: {
+		'200': jsonResponse(validateSkillResponseSchema),
+	},
+};
+
+export const validateSkillNameSpec = {
+	method: 'get',
+	path: '/v1/skills/validate-name/{name}',
+	tags: ['config'],
+	operationId: 'validateSkillName',
+	summary: 'Check if a skill name is valid',
+	parameters: [skillNamePathParameter],
+	responses: {
+		'200': jsonResponse(validateNameResponseSchema),
+	},
+};