Roo to main

packages/types/src/__tests__/skills.test.ts

@@ -0,0 +1,144 @@
+import {
+	validateSkillName,
+	SkillNameValidationError,
+	SKILL_NAME_MIN_LENGTH,
+	SKILL_NAME_MAX_LENGTH,
+	SKILL_NAME_REGEX,
+} from "../skills.js"
+
+describe("validateSkillName", () => {
+	describe("valid names", () => {
+		it("accepts single lowercase word", () => {
+			expect(validateSkillName("myskill")).toEqual({ valid: true })
+		})
+
+		it("accepts lowercase letters and numbers", () => {
+			expect(validateSkillName("skill123")).toEqual({ valid: true })
+		})
+
+		it("accepts hyphenated words", () => {
+			expect(validateSkillName("my-skill")).toEqual({ valid: true })
+		})
+
+		it("accepts multiple hyphenated words", () => {
+			expect(validateSkillName("my-awesome-skill")).toEqual({ valid: true })
+		})
+
+		it("accepts single character", () => {
+			expect(validateSkillName("a")).toEqual({ valid: true })
+		})
+
+		it("accepts single digit", () => {
+			expect(validateSkillName("1")).toEqual({ valid: true })
+		})
+
+		it("accepts maximum length name (64 characters)", () => {
+			const maxLengthName = "a".repeat(SKILL_NAME_MAX_LENGTH)
+			expect(validateSkillName(maxLengthName)).toEqual({ valid: true })
+		})
+	})
+
+	describe("empty or missing names", () => {
+		it("rejects empty string", () => {
+			expect(validateSkillName("")).toEqual({
+				valid: false,
+				error: SkillNameValidationError.Empty,
+			})
+		})
+	})
+
+	describe("names that are too long", () => {
+		it("rejects names longer than 64 characters", () => {
+			const tooLongName = "a".repeat(SKILL_NAME_MAX_LENGTH + 1)
+			expect(validateSkillName(tooLongName)).toEqual({
+				valid: false,
+				error: SkillNameValidationError.TooLong,
+			})
+		})
+	})
+
+	describe("invalid format", () => {
+		it("rejects uppercase letters", () => {
+			expect(validateSkillName("MySkill")).toEqual({
+				valid: false,
+				error: SkillNameValidationError.InvalidFormat,
+			})
+		})
+
+		it("rejects leading hyphen", () => {
+			expect(validateSkillName("-myskill")).toEqual({
+				valid: false,
+				error: SkillNameValidationError.InvalidFormat,
+			})
+		})
+
+		it("rejects trailing hyphen", () => {
+			expect(validateSkillName("myskill-")).toEqual({
+				valid: false,
+				error: SkillNameValidationError.InvalidFormat,
+			})
+		})
+
+		it("rejects consecutive hyphens", () => {
+			expect(validateSkillName("my--skill")).toEqual({
+				valid: false,
+				error: SkillNameValidationError.InvalidFormat,
+			})
+		})
+
+		it("rejects spaces", () => {
+			expect(validateSkillName("my skill")).toEqual({
+				valid: false,
+				error: SkillNameValidationError.InvalidFormat,
+			})
+		})
+
+		it("rejects underscores", () => {
+			expect(validateSkillName("my_skill")).toEqual({
+				valid: false,
+				error: SkillNameValidationError.InvalidFormat,
+			})
+		})
+
+		it("rejects special characters", () => {
+			expect(validateSkillName("my@skill")).toEqual({
+				valid: false,
+				error: SkillNameValidationError.InvalidFormat,
+			})
+		})
+
+		it("rejects dots", () => {
+			expect(validateSkillName("my.skill")).toEqual({
+				valid: false,
+				error: SkillNameValidationError.InvalidFormat,
+			})
+		})
+	})
+})
+
+describe("SKILL_NAME_REGEX", () => {
+	it("matches valid names", () => {
+		expect(SKILL_NAME_REGEX.test("myskill")).toBe(true)
+		expect(SKILL_NAME_REGEX.test("my-skill")).toBe(true)
+		expect(SKILL_NAME_REGEX.test("skill123")).toBe(true)
+		expect(SKILL_NAME_REGEX.test("a1-b2-c3")).toBe(true)
+	})
+
+	it("does not match invalid names", () => {
+		expect(SKILL_NAME_REGEX.test("-start")).toBe(false)
+		expect(SKILL_NAME_REGEX.test("end-")).toBe(false)
+		expect(SKILL_NAME_REGEX.test("double--hyphen")).toBe(false)
+		expect(SKILL_NAME_REGEX.test("UPPER")).toBe(false)
+		expect(SKILL_NAME_REGEX.test("")).toBe(false)
+	})
+})
+
+describe("constants", () => {
+	it("has correct min length", () => {
+		expect(SKILL_NAME_MIN_LENGTH).toBe(1)
+	})
+
+	it("has correct max length", () => {
+		expect(SKILL_NAME_MAX_LENGTH).toBe(64)
+	})
+})

packages/types/src/experiment.ts

@@ -7,15 +7,14 @@ import type { Keys, Equals, AssertEqual } from "./type-fu.js"
  */
 
 export const experimentIds = [
-	"chatSearch",
-	"commitReview",
-	"alwaysIncludeFileDetails",
-	"useLitePrompts",
 	"preventFocusDisruption",
 	"imageGeneration",
 	"runSlashCommand",
-	"multipleNativeToolCalls",
 	"customTools",
+	"chatSearch",
+	"commitReview",
+	"alwaysIncludeFileDetails",
+	"useLitePrompts",
 	"smartMistakeDetection",
 ] as const
 
@@ -45,7 +44,6 @@ export const experimentsSchema = z.object({
 	preventFocusDisruption: z.boolean().optional(),
 	imageGeneration: z.boolean().optional(),
 	runSlashCommand: z.boolean().optional(),
-	multipleNativeToolCalls: z.boolean().optional(),
 	customTools: z.boolean().optional(),
 	smartMistakeDetection: z.boolean().optional(),
 })

packages/types/src/index.ts

@@ -22,6 +22,7 @@ export * from "./message.js"
 export * from "./mode.js"
 export * from "./model.js"
 export * from "./provider-settings.js"
+export * from "./skills.js"
 export * from "./task.js"
 export * from "./todo.js"
 export * from "./telemetry.js"

packages/types/src/providers/moonshot.ts

@@ -53,6 +53,19 @@ export const moonshotModels = {
 		defaultTemperature: 1.0,
 		description: `The kimi-k2-thinking model is a general-purpose agentic reasoning model developed by Moonshot AI. Thanks to its strength in deep reasoning and multi-turn tool use, it can solve even the hardest problems.`,
 	},
+	"kimi-k2.5": {
+		maxTokens: 16_384,
+		contextWindow: 262_144,
+		supportsImages: false,
+		supportsPromptCache: true,
+		inputPrice: 0.6, // $0.60 per million tokens (cache miss)
+		outputPrice: 3.0, // $3.00 per million tokens
+		cacheReadsPrice: 0.1, // $0.10 per million tokens (cache hit)
+		supportsTemperature: true,
+		defaultTemperature: 1.0,
+		description:
+			"Kimi K2.5 is the latest generation of Moonshot AI's Kimi series, featuring improved reasoning capabilities and enhanced performance across diverse tasks.",
+	},
 } as const satisfies Record<string, ModelInfo>
 
 export const MOONSHOT_DEFAULT_TEMPERATURE = 0.6

packages/types/src/skills.ts

@@ -0,0 +1,71 @@
+/**
+ * Skill metadata for discovery (loaded at startup)
+ * Only name and description are required for now
+ */
+export interface SkillMetadata {
+	name: string // Required: skill identifier
+	description: string // Required: when to use this skill
+	path: string // Absolute path to SKILL.md
+	source: "global" | "project" // Where the skill was discovered
+	mode?: string // If set, skill is only available in this mode
+}
+
+/**
+ * Skill name validation constants per agentskills.io specification:
+ * https://agentskills.io/specification
+ *
+ * Name constraints:
+ * - 1-64 characters
+ * - Lowercase letters, numbers, and hyphens only
+ * - Must not start or end with a hyphen
+ * - Must not contain consecutive hyphens
+ */
+export const SKILL_NAME_MIN_LENGTH = 1
+export const SKILL_NAME_MAX_LENGTH = 64
+
+/**
+ * Regex pattern for valid skill names.
+ * Matches: lowercase letters/numbers, optionally followed by groups of hyphen + lowercase letters/numbers.
+ * This ensures no leading/trailing hyphens and no consecutive hyphens.
+ */
+export const SKILL_NAME_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
+
+/**
+ * Error codes for skill name validation.
+ * These can be mapped to translation keys in the frontend or error messages in the backend.
+ */
+export enum SkillNameValidationError {
+	Empty = "empty",
+	TooLong = "too_long",
+	InvalidFormat = "invalid_format",
+}
+
+/**
+ * Result of skill name validation.
+ */
+export interface SkillNameValidationResult {
+	valid: boolean
+	error?: SkillNameValidationError
+}
+
+/**
+ * Validate a skill name according to agentskills.io specification.
+ *
+ * @param name - The skill name to validate
+ * @returns Validation result with error code if invalid
+ */
+export function validateSkillName(name: string): SkillNameValidationResult {
+	if (!name || name.length < SKILL_NAME_MIN_LENGTH) {
+		return { valid: false, error: SkillNameValidationError.Empty }
+	}
+
+	if (name.length > SKILL_NAME_MAX_LENGTH) {
+		return { valid: false, error: SkillNameValidationError.TooLong }
+	}
+
+	if (!SKILL_NAME_REGEX.test(name)) {
+		return { valid: false, error: SkillNameValidationError.InvalidFormat }
+	}
+
+	return { valid: true }
+}

packages/types/src/vscode-extension-host.ts

@@ -20,6 +20,7 @@ import type { GitCommit } from "./git.js"
 import type { McpServer } from "./mcp.js"
 import type { IZgsmModelResponseData, ModelRecord, RouterModels } from "./model.js"
 import type { INotice } from "./notification.js"
+import type { SkillMetadata } from "./skills.js"
 import type { OpenAiCodexRateLimitInfo } from "./providers/openai-codex-rate-limits.js"
 import type { WorktreeIncludeStatus } from "./worktree.js"
 
@@ -132,6 +133,7 @@ export interface ExtensionMessage {
 		| "worktreeIncludeStatus"
 		| "branchWorktreeIncludeResult"
 		| "folderSelected"
+		| "skills"
 	text?: string
 	payload?: any // eslint-disable-line @typescript-eslint/no-explicit-any
 	checkpointWarning?: {
@@ -234,6 +236,7 @@ export interface ExtensionMessage {
 	stepIndex?: number // For browserSessionNavigate: the target step index to display
 	tools?: SerializedCustomToolDefinition[] // For customToolsResult
 	modes?: { slug: string; name: string }[] // For modes response
+	skills?: SkillMetadata[] // For skills response
 	aggregatedCosts?: {
 		// For taskWithAggregatedCosts response
 		totalCost: number
@@ -683,6 +686,11 @@ export interface WebviewMessage {
 		| "createWorktreeInclude"
 		| "checkoutBranch"
 		| "browseForWorktreePath"
+		// Skills messages
+		| "requestSkills"
+		| "createSkill"
+		| "deleteSkill"
+		| "openSkillFile"
 	text?: string
 	// costrict-start
 	issueId?: string
@@ -723,6 +731,9 @@ export interface WebviewMessage {
 	timeout?: number
 	payload?: WebViewMessagePayload
 	source?: "global" | "project"
+	skillName?: string // For skill operations (createSkill, deleteSkill, openSkillFile)
+	skillMode?: string // For skill operations (mode restriction)
+	skillDescription?: string // For createSkill (skill description)
 	requestId?: string
 	ids?: string[]
 	hasSystemPromptOverride?: boolean