Add Roo Code types

Author: cte

benchmark/apps/cli/src/exercises.ts

@@ -3,28 +3,28 @@ import * as fs from "fs"
 
 import { filesystem } from "gluegun"
 
-import { type Language, languages } from "@benchmark/types"
+import { type ExerciseLanguage, exerciseLanguages } from "@benchmark/types"
 
 import { exercisesPath } from "./paths.js"
 
-let exercisesByLanguage: Record<Language, string[]> | null = null
+let exercisesByLanguage: Record<ExerciseLanguage, string[]> | null = null
 
 export const getExercises = () => {
 	if (exercisesByLanguage !== null) {
 		return exercisesByLanguage
 	}
 
-	const getLanguageExercises = (language: Language) =>
+	const getLanguageExercises = (language: ExerciseLanguage) =>
 		fs.existsSync(path.resolve(exercisesPath, language))
 			? filesystem
 					.subdirectories(path.resolve(exercisesPath, language))
 					.map((exercise) => path.basename(exercise))
 					.filter((exercise) => !exercise.startsWith("."))
 			: []
 
-	exercisesByLanguage = languages.reduce(
+	exercisesByLanguage = exerciseLanguages.reduce(
 		(collect, language) => ({ ...collect, [language]: getLanguageExercises(language) }),
-		{} as Record<Language, string[]>,
+		{} as Record<ExerciseLanguage, string[]>,
 	)
 
 	return exercisesByLanguage

benchmark/apps/cli/src/index.ts

@@ -7,14 +7,14 @@ import { build, filesystem, GluegunPrompt, GluegunToolbox } from "gluegun"
 import { runTests } from "@vscode/test-electron"
 import { execa, parseCommandString } from "execa"
 
-import { type Language, languages, IpcOrigin, IpcMessageType, TaskEventName } from "@benchmark/types"
+import { type ExerciseLanguage, exerciseLanguages, IpcOrigin, IpcMessageType, TaskEventName } from "@benchmark/types"
 import { type Run, findRun, createRun, finishRun, createTask, Task, getTasks, updateTask } from "@benchmark/db"
 import { IpcServer } from "@benchmark/ipc"
 
 import { __dirname, extensionDevelopmentPath, extensionTestsPath, exercisesPath } from "./paths.js"
 import { getExercises } from "./exercises.js"
 
-const testCommands: Record<Language, { commands: string[]; timeout?: number; cwd?: string }> = {
+const testCommands: Record<ExerciseLanguage, { commands: string[]; timeout?: number; cwd?: string }> = {
 	cpp: { commands: ["cmake -G 'Unix\\ Makefiles' -DEXERCISM_RUN_ALL_TESTS=1 ..", "make"], cwd: "build" }, // timeout 15s bash -c "cd '$dir' && mkdir -p build && cd build && cmake -G 'Unix Makefiles' -DEXERCISM_RUN_ALL_TESTS=1 .. >/dev/null 2>&1 && make >/dev/null 2>&1"
 	go: { commands: ["go test"] }, // timeout 15s bash -c "cd '$dir' && go test > /dev/null 2>&1"
 	java: { commands: ["./gradlew test"] }, // timeout --foreground 15s bash -c "cd '$dir' && ./gradlew test > /dev/null 2>&1"
@@ -28,7 +28,7 @@ const run = async (toolbox: GluegunToolbox) => {
 
 	let { language, exercise } = config
 
-	if (![undefined, ...languages, "all"].includes(language)) {
+	if (![undefined, ...exerciseLanguages, "all"].includes(language)) {
 		throw new Error(`Language is invalid: ${language}`)
 	}
 
@@ -49,15 +49,15 @@ const run = async (toolbox: GluegunToolbox) => {
 		})
 
 		if (language === "all") {
-			for (const language of languages) {
-				const exercises = getExercises()[language as Language]
+			for (const language of exerciseLanguages) {
+				const exercises = getExercises()[language as ExerciseLanguage]
 
 				await pMap(exercises, (exercise) => createTask({ runId: run.id, language, exercise }), {
 					concurrency: 10,
 				})
 			}
 		} else if (exercise === "all") {
-			const exercises = getExercises()[language as Language]
+			const exercises = getExercises()[language as ExerciseLanguage]
 			await pMap(exercises, (exercise) => createTask({ runId: run.id, language, exercise }), { concurrency: 10 })
 		} else {
 			language = language || (await askLanguage(prompt))
@@ -166,17 +166,17 @@ const runExercise = async ({ run, task }: { run: Run; task: Task }) => {
 }
 
 const askLanguage = async (prompt: GluegunPrompt) => {
-	const { language } = await prompt.ask<{ language: Language }>({
+	const { language } = await prompt.ask<{ language: ExerciseLanguage }>({
 		type: "select",
 		name: "language",
 		message: "Which language?",
-		choices: [...languages],
+		choices: [...exerciseLanguages],
 	})
 
 	return language
 }
 
-const askExercise = async (prompt: GluegunPrompt, language: Language) => {
+const askExercise = async (prompt: GluegunPrompt, language: ExerciseLanguage) => {
 	const exercises = filesystem.subdirectories(path.join(exercisesPath, language))
 
 	if (exercises.length === 0) {

benchmark/apps/web/src/lib/server/exercises.ts

@@ -4,7 +4,7 @@ import * as fs from "fs/promises"
 import * as path from "path"
 import { fileURLToPath } from "url"
 
-import { Language, languages } from "@benchmark/types"
+import { ExerciseLanguage, exerciseLanguages } from "@benchmark/types"
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 
@@ -24,7 +24,7 @@ const EXERCISES_BASE_PATH = path.resolve(__dirname, "../../../../../../../exerci
 
 export const getExercises = async () => {
 	const result = await Promise.all(
-		languages.map(async (language) => {
+		exerciseLanguages.map(async (language) => {
 			const languagePath = path.join(EXERCISES_BASE_PATH, language)
 			const exercises = await listDirectories(languagePath)
 			return exercises.map((exercise) => `${language}/${exercise}`)
@@ -34,5 +34,5 @@ export const getExercises = async () => {
 	return result.flat()
 }
 
-export const getExercisesForLanguage = async (language: Language) =>
+export const getExercisesForLanguage = async (language: ExerciseLanguage) =>
 	listDirectories(path.join(EXERCISES_BASE_PATH, language))

benchmark/apps/web/src/lib/server/runs.ts

@@ -7,7 +7,7 @@ import os from "os"
 import { revalidatePath } from "next/cache"
 import pMap from "p-map"
 
-import { Language, languages } from "@benchmark/types"
+import { ExerciseLanguage, exerciseLanguages } from "@benchmark/types"
 import * as db from "@benchmark/db"
 
 import { CreateRun } from "@/lib/schemas"
@@ -27,10 +27,10 @@ export async function createRun({ suite, exercises = [], ...values }: CreateRun)
 				throw new Error("Invalid exercise path: " + path)
 			}
 
-			await db.createTask({ ...values, runId: run.id, language: language as Language, exercise })
+			await db.createTask({ ...values, runId: run.id, language: language as ExerciseLanguage, exercise })
 		}
 	} else {
-		for (const language of languages) {
+		for (const language of exerciseLanguages) {
 			const exercises = await getExercisesForLanguage(language)
 
 			await pMap(exercises, (exercise) => db.createTask({ ...values, runId: run.id, language, exercise }), {

benchmark/packages/db/src/queries/tasks.ts

@@ -1,6 +1,6 @@
 import { and, eq } from "drizzle-orm"
 
-import type { Language } from "@benchmark/types"
+import type { ExerciseLanguage } from "@benchmark/types"
 
 import { RecordNotFoundError, RecordNotCreatedError } from "./errors.js"
 import type { InsertTask, UpdateTask } from "../schema.js"
@@ -49,7 +49,7 @@ export const updateTask = async (id: number, values: UpdateTask) => {
 }
 type GetTask = {
 	runId: number
-	language: Language
+	language: ExerciseLanguage
 	exercise: string
 }
 

benchmark/packages/db/src/schema.ts

@@ -3,7 +3,7 @@ import { relations } from "drizzle-orm"
 import { createInsertSchema } from "drizzle-zod"
 import { z } from "zod"
 
-import { languages } from "@benchmark/types"
+import { exerciseLanguages } from "@benchmark/types"
 
 /**
  * runs
@@ -45,7 +45,7 @@ export const tasks = sqliteTable(
 			.references(() => runs.id)
 			.notNull(),
 		taskMetricsId: integer({ mode: "number" }).references(() => taskMetrics.id),
-		language: text({ enum: languages }).notNull(),
+		language: text({ enum: exerciseLanguages }).notNull(),
 		exercise: text().notNull(),
 		passed: integer({ mode: "boolean" }),
 		startedAt: integer({ mode: "timestamp" }),

benchmark/packages/types/src/exercises.ts

@@ -0,0 +1,10 @@
+/**
+ * ExerciseLanguage
+ */
+
+export const exerciseLanguages = ["cpp", "go", "java", "javascript", "python", "rust"] as const
+
+export type ExerciseLanguage = (typeof exerciseLanguages)[number]
+
+export const isExerciseLanguage = (value: string): value is ExerciseLanguage =>
+	exerciseLanguages.includes(value as ExerciseLanguage)

benchmark/packages/types/src/index.ts

@@ -1,125 +1,3 @@
-import { z } from "zod"
-
-/**
- * Language
- */
-
-export const languages = ["cpp", "go", "java", "javascript", "python", "rust"] as const
-
-export type Language = (typeof languages)[number]
-
-export const isLanguage = (value: string): value is Language => languages.includes(value as Language)
-
-/**
- * TaskEvent
- */
-
-export enum TaskEventName {
-	Connect = "Connect",
-	TaskStarted = "TaskStarted",
-	Message = "Message",
-	TaskTokenUsageUpdated = "TaskTokenUsageUpdated",
-	TaskFinished = "TaskFinished",
-}
-
-export const taskEventSchema = z.discriminatedUnion("eventName", [
-	z.object({
-		eventName: z.literal(TaskEventName.Connect),
-		data: z.object({ task: z.object({ id: z.number() }) }),
-	}),
-	z.object({
-		eventName: z.literal(TaskEventName.TaskStarted),
-		data: z.object({ task: z.object({ id: z.number() }) }),
-	}),
-	z.object({
-		eventName: z.literal(TaskEventName.Message),
-		data: z.object({
-			task: z.object({ id: z.number() }),
-			message: z.object({
-				taskId: z.string(),
-				action: z.enum(["created", "updated"]),
-				message: z.object({
-					// See ClineMessage.
-					ts: z.number(),
-					type: z.enum(["ask", "say"]),
-					ask: z.string().optional(),
-					say: z.string().optional(),
-					partial: z.boolean().optional(),
-					text: z.string().optional(),
-					reasoning: z.string().optional(),
-				}),
-			}),
-		}),
-	}),
-	z.object({
-		eventName: z.literal(TaskEventName.TaskTokenUsageUpdated),
-		data: z.object({
-			task: z.object({ id: z.number() }),
-			usage: z.object({}),
-		}),
-	}),
-	z.object({
-		eventName: z.literal(TaskEventName.TaskFinished),
-		data: z.object({ task: z.object({ id: z.number() }), taskMetrics: z.unknown() }),
-	}),
-])
-
-export type TaskEvent = z.infer<typeof taskEventSchema>
-
-/**
- * TaskCommand
- */
-
-export enum TaskCommandName {
-	StartNewTask = "StartNewTask",
-}
-
-export const taskCommandSchema = z.discriminatedUnion("commandName", [
-	z.object({
-		commandName: z.literal(TaskCommandName.StartNewTask),
-		data: z.object({
-			text: z.string(),
-			images: z.array(z.string()).optional(),
-		}),
-	}),
-])
-
-export type TaskCommand = z.infer<typeof taskCommandSchema>
-
-/**
- * IpcMessage
- */
-
-export enum IpcMessageType {
-	Ack = "Ack",
-	TaskCommand = "TaskCommand",
-	TaskEvent = "TaskEvent",
-}
-
-export enum IpcOrigin {
-	Client = "client",
-	Server = "server",
-	Relay = "relay",
-}
-
-export const ipcMessageSchema = z.discriminatedUnion("type", [
-	z.object({
-		type: z.literal(IpcMessageType.Ack),
-		origin: z.literal(IpcOrigin.Server),
-		data: z.object({ clientId: z.string() }),
-	}),
-	z.object({
-		type: z.literal(IpcMessageType.TaskCommand),
-		origin: z.literal(IpcOrigin.Client),
-		clientId: z.string(),
-		data: taskCommandSchema,
-	}),
-	z.object({
-		type: z.literal(IpcMessageType.TaskEvent),
-		origin: z.union([z.literal(IpcOrigin.Server), z.literal(IpcOrigin.Relay)]),
-		relayClientId: z.string().optional(),
-		data: taskEventSchema,
-	}),
-])
-
-export type IpcMessage = z.infer<typeof ipcMessageSchema>
+export * from "./exercises.js"
+export * from "./ipc.js"
+export * from "./roo-code.js"