@kradle/cli 0.0.16 → 0.1.0

package/dist/lib/{evaluation → experiment}/tui.js

@@ -39,7 +39,7 @@ const RenderRunLine = ({ state, total, isSelected, padding, }) => {
     const summaryText = summary.length > maxSummaryLength ? summary.slice(0, maxSummaryLength - 1) + "…" : summary;
     return (_jsxs(Text, { inverse: isSelected, children: [_jsx(Text, { color: color, children: icon }), " ", indexLabel, " ", _jsx(Text, { color: color, children: statusLabel }), elapsedLabel ? (_jsxs(_Fragment, { children: [" ", _jsx(Text, { dimColor: true, children: elapsedLabel })] })) : null, " ", _jsx(Text, { dimColor: true, children: summaryText })] }));
 };
-const EvaluationUI = ({ evaluationName, states, statusCounts, onQuit, onOpenRun }) => {
+const ExperimentUI = ({ experimentName, states, statusCounts, onQuit, onOpenRun }) => {
     const [selectedIndex, setSelectedIndex] = useState(0);
     const [scrollOffset, setScrollOffset] = useState(0);
     const [tick, setTick] = useState(0); // force elapsed-time updates
@@ -89,7 +89,7 @@ const EvaluationUI = ({ evaluationName, states, statusCounts, onQuit, onOpenRun
     const rangeEnd = Math.min(scrollOffset + rowsAvailable, states.length);
     const horizontalRule = "─".repeat(Math.min(process.stdout.columns || 80, 80));
     const padding = states.length.toString().length;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: `Evaluation: ${evaluationName}` }), _jsx(Text, { dimColor: true, children: horizontalRule }), _jsx(Text, { dimColor: true, children: "q:quit \u2191/\u2193/j/k:select o:open in browser" }), _jsx(Text, { children: " " }), _jsxs(Box, { flexDirection: "column", children: [visibleRuns.map((state, index) => (_jsx(RenderRunLine, { state: state, total: states.length, isSelected: scrollOffset + index === selectedIndex, padding: padding }, state.index))), visibleRuns.length < rowsAvailable
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: `Experiment: ${experimentName}` }), _jsx(Text, { dimColor: true, children: horizontalRule }), _jsx(Text, { dimColor: true, children: "q:quit \u2191/\u2193/j/k:select o:open in browser" }), _jsx(Text, { children: " " }), _jsxs(Box, { flexDirection: "column", children: [visibleRuns.map((state, index) => (_jsx(RenderRunLine, { state: state, total: states.length, isSelected: scrollOffset + index === selectedIndex, padding: padding }, state.index))), visibleRuns.length < rowsAvailable
                         ? Array.from({ length: rowsAvailable - visibleRuns.length }).map((_, index) => (_jsx(Text, { children: " " }, `empty-${index}`)))
                         : null] }), showScroll ? _jsx(Text, { dimColor: true, children: `[${rangeStart}-${rangeEnd} of ${states.length}]` }) : _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: horizontalRule }), _jsxs(Text, { children: [_jsx(Text, { children: "Completed: " }), _jsx(Text, { color: "green", children: statusCounts.completed }), _jsx(Text, { children: ` | Active: ` }), _jsx(Text, { color: "yellow", children: statusCounts.active }), _jsx(Text, { children: ` | Queued: ` }), _jsx(Text, { dimColor: true, children: statusCounts.queued }), statusCounts.errors > 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { children: ` | Errors: ` }), _jsx(Text, { color: "red", children: statusCounts.errors })] })) : null] })] }));
 };
@@ -125,6 +125,6 @@ export class TUI {
         this.app.rerender(this.renderApp());
     }
     renderApp() {
-        return (_jsx(EvaluationUI, { evaluationName: this.options.evaluationName, states: this.states, statusCounts: this.statusCounts, onQuit: this.options.onQuit, onOpenRun: this.options.onOpenRun }));
+        return (_jsx(ExperimentUI, { experimentName: this.options.experimentName, states: this.states, statusCounts: this.statusCounts, onQuit: this.options.onQuit, onOpenRun: this.options.onOpenRun }));
     }
 }

package/dist/lib/{evaluation → experiment}/types.d.ts

@@ -10,6 +10,7 @@ export declare const RunConfigSchema: z.ZodObject<{
         agent: z.ZodString;
         role: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type RunConfig = z.infer<typeof RunConfigSchema>;
 export declare const ManifestSchema: z.ZodObject<{
@@ -19,6 +20,7 @@ export declare const ManifestSchema: z.ZodObject<{
             agent: z.ZodString;
             role: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
@@ -113,11 +115,11 @@ export declare const RunLogsResponseSchema: z.ZodObject<{
     logs: z.ZodArray<z.ZodUnknown>;
 }, z.core.$strip>;
 export type RunLogsResponse = z.infer<typeof RunLogsResponseSchema>;
-export declare const EvaluationMetadataSchema: z.ZodObject<{
-    currentIteration: z.ZodNumber;
+export declare const ExperimentMetadataSchema: z.ZodObject<{
+    currentVersion: z.ZodNumber;
 }, z.core.$strip>;
-export type EvaluationMetadata = z.infer<typeof EvaluationMetadataSchema>;
-export interface EvaluationOptions {
+export type ExperimentMetadata = z.infer<typeof ExperimentMetadataSchema>;
+export interface ExperimentOptions {
     new: boolean;
     maxConcurrent: number;
     openMetabase?: boolean;

package/dist/lib/{evaluation → experiment}/types.js

@@ -8,6 +8,7 @@ export const ParticipantSchema = z.object({
 export const RunConfigSchema = z.object({
     challenge_slug: z.string(),
     participants: z.array(ParticipantSchema),
+    tags: z.array(z.string()).optional(),
 });
 // Manifest returned by config.ts main()
 export const ManifestSchema = z.object({
@@ -66,9 +67,9 @@ export const RunStatusResponseSchema = z.object({
 export const RunLogsResponseSchema = z.object({
     logs: z.array(z.unknown()),
 });
-// Evaluation metadata stored in .evaluation.json
-export const EvaluationMetadataSchema = z.object({
-    currentIteration: z.number(),
+// Experiment metadata stored in .experiment.json
+export const ExperimentMetadataSchema = z.object({
+    currentVersion: z.number(),
 });
 // Icons and colors for TUI
 export const STATUS_ICONS = {

package/dist/lib/flags.d.ts

@@ -0,0 +1,47 @@
+/**
+ * All available config flags that can be used by commands.
+ * Each flag has an `env` property that allows it to be set via environment variable.
+ */
+export declare const ALL_CONFIG_FLAGS: {
+    readonly "api-url": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    readonly "web-url": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    readonly "studio-api-url": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    readonly "studio-url": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    readonly "api-key": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    readonly "challenges-path": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+};
+/**
+ * Type representing all config flag keys.
+ */
+export type ConfigFlagKey = keyof typeof ALL_CONFIG_FLAGS;
+/**
+ * Type representing the parsed values of all config flags.
+ */
+export type AllConfigFlagValues = {
+    [K in ConfigFlagKey]: string;
+};
+/**
+ * Returns a subset of config flags for use in a command's static flags definition.
+ *
+ * @example
+ * // In a command file:
+ * static override flags = {
+ *   ...getConfigFlags("api-key", "web-api-url", "studio-api-url"),
+ *   // other command-specific flags
+ * };
+ *
+ * @param keys - The config flag keys to include.
+ * @returns An object containing only the specified flags
+ */
+export declare function getConfigFlags<K extends ConfigFlagKey>(...keys: K[]): Pick<typeof ALL_CONFIG_FLAGS, K>;
+/**
+ * Helper type to extract the parsed flag values for a subset of config flags.
+ * Use this to type the flags object after parsing.
+ *
+ * @example
+ * type MyFlags = ConfigFlagValues<"api-key" | "web-api-url">;
+ * // Results in: { "api-key": string; "web-api-url": string }
+ */
+export type ConfigFlagValues<K extends ConfigFlagKey> = {
+    [P in K]: AllConfigFlagValues[P];
+};

package/dist/lib/flags.js

@@ -0,0 +1,63 @@
+import { Flags } from "@oclif/core";
+import { untildify } from "./utils.js";
+/**
+ * All available config flags that can be used by commands.
+ * Each flag has an `env` property that allows it to be set via environment variable.
+ */
+export const ALL_CONFIG_FLAGS = {
+    "api-url": Flags.string({
+        description: "Kradle Web API URL",
+        env: "KRADLE_API_URL",
+        required: true,
+        default: "https://api.kradle.ai/v0",
+    }),
+    "web-url": Flags.string({
+        description: "Kradle Web URL, used to display the run URL",
+        env: "KRADLE_WEB_URL",
+        required: true,
+        default: "https://kradle.ai",
+    }),
+    "studio-api-url": Flags.string({
+        description: "Kradle Studio API URL, used to communicate with the Studio API",
+        env: "KRADLE_STUDIO_API_URL",
+        required: true,
+        default: "http://localhost:2999/api/v0",
+    }),
+    "studio-url": Flags.string({
+        description: "Kradle Studio URL, used to display the run URL in Studio",
+        env: "KRADLE_STUDIO_URL",
+        required: true,
+        default: "kradle://open",
+    }),
+    "api-key": Flags.string({
+        description: "Kradle API key",
+        env: "KRADLE_API_KEY",
+        required: true,
+    }),
+    "challenges-path": Flags.string({
+        description: "Absolute path to the challenges directory",
+        env: "KRADLE_CHALLENGES_PATH",
+        default: "~/Documents/kradle-studio/challenges",
+        parse: async (input) => untildify(input),
+    }),
+};
+/**
+ * Returns a subset of config flags for use in a command's static flags definition.
+ *
+ * @example
+ * // In a command file:
+ * static override flags = {
+ *   ...getConfigFlags("api-key", "web-api-url", "studio-api-url"),
+ *   // other command-specific flags
+ * };
+ *
+ * @param keys - The config flag keys to include.
+ * @returns An object containing only the specified flags
+ */
+export function getConfigFlags(...keys) {
+    const result = {};
+    for (const key of keys) {
+        result[key] = ALL_CONFIG_FLAGS[key];
+    }
+    return result;
+}

package/dist/lib/schemas.d.ts

@@ -40,6 +40,37 @@ export declare const ChallengeSchema: z.ZodObject<{
     updateTime: z.ZodOptional<z.ZodString>;
     creator: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+export declare const ChallengeConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    domain: z.ZodString;
+    world: z.ZodString;
+    challengeConfig: z.ZodObject<{
+        cheat: z.ZodBoolean;
+        datapack: z.ZodBoolean;
+        gameMode: z.ZodEnum<{
+            survival: "survival";
+            creative: "creative";
+            adventure: "adventure";
+            spectator: "spectator";
+        }>;
+    }, z.core.$strip>;
+    task: z.ZodOptional<z.ZodString>;
+    roles: z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        specificTask: z.ZodOptional<z.ZodString>;
+        minParticipants: z.ZodOptional<z.ZodNumber>;
+        maxParticipants: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    objective: z.ZodObject<{
+        fieldName: z.ZodString;
+        direction: z.ZodEnum<{
+            maximize: "maximize";
+            minimize: "minimize";
+        }>;
+    }, z.core.$strip>;
+    endStates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
 export declare const ChallengesResponseSchema: z.ZodObject<{
     challenges: z.ZodArray<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
@@ -135,6 +166,7 @@ export declare const AgentsResponseSchema: z.ZodObject<{
     nextPageToken: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ChallengeSchemaType = z.infer<typeof ChallengeSchema>;
+export type ChallengeConfigSchemaType = z.infer<typeof ChallengeConfigSchema>;
 export type ChallengesResponseType = z.infer<typeof ChallengesResponseSchema>;
 export type HumanSchemaType = z.infer<typeof HumanSchema>;
 export type RunResponseType = z.infer<typeof RunResponseSchema>;

package/dist/lib/schemas.js

@@ -28,6 +28,14 @@ export const ChallengeSchema = z.object({
     updateTime: z.string().optional(),
     creator: z.string().optional(),
 });
+export const ChallengeConfigSchema = ChallengeSchema.omit({
+    slug: true,
+    id: true,
+    visibility: true,
+    creationTime: true,
+    updateTime: true,
+    creator: true,
+});
 export const ChallengesResponseSchema = z.object({
     challenges: z.array(ChallengeSchema),
     nextPageToken: z.string().optional(),

package/dist/lib/utils.d.ts

@@ -1,5 +1,4 @@
 import type { Dirent } from "node:fs";
-import type { Config } from "./config.js";
 export declare function loadTemplateRun(): Promise<Record<string, unknown>>;
 /**
  * Resolve tildes in a path to the home directory
@@ -33,34 +32,34 @@ export declare function getStaticResourcePath(name: string): string;
  */
 export declare function readDirSorted(dir: string): Promise<Dirent[]>;
 /**
- * Runs a NodeJS module. The module is executed in the current working directory, and the environment is set to the given config.
+ * Runs a NodeJS module. The module is executed in the current working directory, and the environment is set to the given env.
  * stdout & stdout are piped to the parent process.
  *
  * Returns a promise that resolves when the module completes.
  *
  * @param file The file to execute.
- * @param config The configuration to use.
+ * @param env The environment variables to set.
  * @param options The options to use.
  * @param options.silent Whether to suppress stdout.
  * @returns A promise that resolves when the command completes.
  */
-export declare function runNodeModule(file: string, config: Config, options?: {
+export declare function runNodeModule(file: string, env: Record<string, string>, options?: {
     silent?: boolean;
 }): Promise<undefined>;
 /**
  * Execute a TypeScript file using NodeJS's built-in TS support.
  *
  * @param filePath The path to the TypeScript file.
- * @param config The configuration to use.
+ * @param env The environment variables to set.
  * @param options The options to use.
  * @param options.silent Whether to suppress stdout.
  * @returns The result of the execution.
  */
-export declare function executeTypescriptFile(filePath: string, config: Config, options?: {
+export declare function executeTypescriptFile(filePath: string, env: Record<string, string>, options?: {
     silent?: boolean;
 }): Promise<unknown>;
 /**
- * Executes an arbitrary command. The command is spawned in the current working directory, and the environment is set to the given config.
+ * Executes an arbitrary command. The command is spawned in the current working directory, and the environment is set to the given env.
  *
  * stdout will be returned as a string.
  * if stderr is not empty, an error will be thrown.
@@ -76,17 +75,17 @@ export declare function executeCommand(command: string, args: string[], options?
     cwd?: string;
 }): Promise<string>;
 /**
- * Executes an arbitrary NodeJS command. The command is spawned in the current working directory, and the environment is set to the given config.
+ * Executes an arbitrary NodeJS command. The command is spawned in the current working directory, and the environment is set to the given env.
  * It will use the process.execPath of the current process to find the NodeJS executable.
  *
  * stdout will be returned as a string.
  * if stderr is not empty, an error will be thrown.
  *
  * @param args The arguments to pass to the command.
- * @param config The configuration to use.
+ * @param env The environment variables to set.
  * @returns A promise that resolves with the stdout of the command.
  */
-export declare function executeNodeCommand(args: string[], config: Config): Promise<string>;
+export declare function executeNodeCommand(args: string[], env: Record<string, string>): Promise<string>;
 /**
  * Open a URL in the default browser.
  * This is fire-and-forget, so we don't wait for it to complete.

package/dist/lib/utils.js

@@ -75,22 +75,22 @@ export async function readDirSorted(dir) {
     return files.sort((a, b) => a.name.localeCompare(b.name));
 }
 /**
- * Runs a NodeJS module. The module is executed in the current working directory, and the environment is set to the given config.
+ * Runs a NodeJS module. The module is executed in the current working directory, and the environment is set to the given env.
  * stdout & stdout are piped to the parent process.
  *
  * Returns a promise that resolves when the module completes.
  *
  * @param file The file to execute.
- * @param config The configuration to use.
+ * @param env The environment variables to set.
  * @param options The options to use.
  * @param options.silent Whether to suppress stdout.
  * @returns A promise that resolves when the command completes.
  */
-export function runNodeModule(file, config, options = {}) {
+export function runNodeModule(file, env, options = {}) {
     return new Promise((resolve, reject) => {
         const child = fork(file, {
             cwd: path.resolve(process.cwd()),
-            env: { ...process.env, ...config },
+            env: { ...process.env, ...env },
             silent: options.silent,
         });
         child.on("close", (code) => {
@@ -108,16 +108,16 @@ export function runNodeModule(file, config, options = {}) {
  * Execute a TypeScript file using NodeJS's built-in TS support.
  *
  * @param filePath The path to the TypeScript file.
- * @param config The configuration to use.
+ * @param env The environment variables to set.
  * @param options The options to use.
  * @param options.silent Whether to suppress stdout.
  * @returns The result of the execution.
  */
-export async function executeTypescriptFile(filePath, config, options = {}) {
-    return await runNodeModule(filePath, config, options);
+export async function executeTypescriptFile(filePath, env, options = {}) {
+    return await runNodeModule(filePath, env, options);
 }
 /**
- * Executes an arbitrary command. The command is spawned in the current working directory, and the environment is set to the given config.
+ * Executes an arbitrary command. The command is spawned in the current working directory, and the environment is set to the given env.
  *
  * stdout will be returned as a string.
  * if stderr is not empty, an error will be thrown.
@@ -155,18 +155,18 @@ export async function executeCommand(command, args, options) {
     });
 }
 /**
- * Executes an arbitrary NodeJS command. The command is spawned in the current working directory, and the environment is set to the given config.
+ * Executes an arbitrary NodeJS command. The command is spawned in the current working directory, and the environment is set to the given env.
  * It will use the process.execPath of the current process to find the NodeJS executable.
  *
  * stdout will be returned as a string.
  * if stderr is not empty, an error will be thrown.
  *
  * @param args The arguments to pass to the command.
- * @param config The configuration to use.
+ * @param env The environment variables to set.
  * @returns A promise that resolves with the stdout of the command.
  */
-export async function executeNodeCommand(args, config) {
-    return executeCommand(process.execPath, args, { env: config });
+export async function executeNodeCommand(args, env) {
+    return executeCommand(process.execPath, args, { env });
 }
 /**
  * Open a URL in the default browser.