@iowarp/clio-coder 0.4.5 → 0.4.7

package/src/cli/run.ts

@@ -179,7 +179,8 @@ function explicitSkillPathErrors(skillPaths: ReadonlyArray<string>): string[] {
  * is checked, not expansion: a template that exists but refuses (an untrusted
  * project root, an unreadable body) has its own message, which the headless
  * boot path already prints from the expansion itself. Deciding that here would
- * duplicate the trust rules and put two refusals on one token.
+ * duplicate the trust rules and put two refusals on one token. A display-only
+ * template is the one expansion decided here, because it needs no boot at all.
  *
  * Both modules are imported lazily, so a task that does not start with a slash
  * pays for neither. The laziness is a startup-cost choice and nothing more: for
@@ -191,18 +192,30 @@ function explicitSkillPathErrors(skillPaths: ReadonlyArray<string>): string[] {
  * closure sits on. Boundaries rule6 in `tests/boundaries/check-boundaries.ts`
  * holds both halves of that.
  */
-async function headlessSlashCommandRefusal(task: string): Promise<string | null> {
+type HeadlessSlashPreflight = { refusal: string } | { display: string } | null;
+
+async function headlessSlashPreflight(task: string): Promise<HeadlessSlashPreflight> {
 	if (!task.trim().startsWith("/")) return null;
 	const { parseSlashCommand } = await import("../interactive/slash-commands.js");
 	const command = parseSlashCommand(task);
 	if (command.kind === "skill-invocation" || command.kind === "unknown" || command.kind === "empty") return null;
 	if (command.kind !== "unknown-command") {
-		return "interactive commands are not supported by clio-coder run; use interactive chat or the corresponding CLI command";
+		return {
+			refusal:
+				"interactive commands are not supported by clio-coder run; use interactive chat or the corresponding CLI command",
+		};
 	}
-	const { loadPromptTemplates } = await import("../domains/resources/index.js");
+	const { expandPromptTemplateInput, loadPromptTemplates } = await import("../domains/resources/index.js");
 	const templates = loadPromptTemplates({ cwd: process.cwd() });
-	if (templates.items.some((template) => template.name === command.token)) return null;
-	return `/${command.token} is not a command. Type /help for the list.`;
+	if (!templates.items.some((template) => template.name === command.token)) {
+		return { refusal: `/${command.token} is not a command. Type /help for the list.` };
+	}
+	// A display-only template is for the operator, so it is answered here and
+	// costs no boot: no provider, no session, no model. Everything else, the
+	// refusals included, stays with the boot path as described above.
+	const expansion = expandPromptTemplateInput(task, templates);
+	if (expansion.expanded === false && expansion.display) return { display: expansion.display.text };
+	return null;
 }
 
 export async function runClioRun(
@@ -266,11 +279,15 @@ export async function runClioRun(
 			if (parsed.agentId === undefined) {
 				// Reject unknown and unsupported interactive commands before boot;
 				// neither has a headless handler that could honor the request.
-				const slashRefusal = await headlessSlashCommandRefusal(assembled.prompt);
-				if (slashRefusal !== null) {
-					process.stderr.write(`clio-coder run: ${slashRefusal}\n`);
+				const preflight = await headlessSlashPreflight(assembled.prompt);
+				if (preflight !== null && "refusal" in preflight) {
+					process.stderr.write(`clio-coder run: ${preflight.refusal}\n`);
 					return 2;
 				}
+				if (preflight !== null) {
+					process.stdout.write(`${preflight.display}\n`);
+					return 0;
+				}
 				// An explicit --target override is a one-run target; a missing id is an
 				// operator config error, not an assistant response. Reject it before the
 				// headless turn so the resolver diagnostic never streams to stdout as a

package/src/cli/select.ts

@@ -48,6 +48,8 @@ export interface SelectOptions<T> {
 	backLabel?: string;
 	/** Rows to show at once. Defaults to what the terminal has room for. */
 	maxVisible?: number;
+	/** Filter a long list by typing; q/j/k are text in this mode. */
+	searchable?: boolean;
 	/**
 	 * Erase the menu once it is answered, leaving the caller's transcript to say
 	 * what was chosen. A wizard that redraws its own answer rows needs this; a
@@ -243,7 +245,7 @@ function viewportFor(output: NodeJS.WriteStream, overhead: number, total: number
 export async function promptSelect<T>(options: SelectOptions<T>): Promise<SelectResult<T>> {
 	const input = options.input ?? process.stdin;
 	const output = options.output ?? process.stdout;
-	const choices = options.choices;
+	let choices = options.choices;
 	if (choices.length === 0) return { kind: "back" };
 
 	const rail = options.railPrefix ?? "";
@@ -255,15 +257,25 @@ export async function promptSelect<T>(options: SelectOptions<T>): Promise<Select
 
 	let index = Math.min(Math.max(options.initialIndex ?? 0, 0), choices.length - 1);
 	let windowStart = 0;
+	let query = "";
+	const filter = () => {
+		choices = options.choices.filter((choice) => choice.label.toLowerCase().includes(query.toLowerCase()));
+		index = 0;
+		windowStart = 0;
+		render();
+	};
 
 	const render = (): void => {
-		const viewport = viewportFor(output, head.length + 5, choices.length, options.maxVisible);
+		const viewport = viewportFor(output, head.length + (options.searchable ? 6 : 5), choices.length, options.maxVisible);
 		if (index < windowStart) windowStart = index;
 		else if (index >= windowStart + viewport) windowStart = index - viewport + 1;
 		windowStart = Math.max(0, Math.min(windowStart, choices.length - viewport));
 		const lines: string[] = [];
 		for (const line of head) lines.push(`${rail}${line}`.trimEnd());
 		if (head.length > 0) lines.push(rail.trimEnd());
+		if (options.searchable)
+			lines.push(`${rail}${truncate(`Filter: ${query || "(type to search)"}`, terminalColumns(output) - railWidth)}`);
+		if (choices.length === 0) lines.push(`${rail}No matching models`);
 		lines.push(
 			...choiceRows(
 				{
@@ -284,7 +296,8 @@ export async function promptSelect<T>(options: SelectOptions<T>): Promise<Select
 		// "quit" reads as two different exits.
 		const legend = ["↑/↓ move", "enter select"];
 		if (options.backLabel !== undefined && options.backLabel !== "quit") legend.push(`esc ${options.backLabel}`);
-		legend.push(options.backLabel === "quit" ? "esc or q quit" : "q quit");
+		if (options.searchable) legend.push("type to filter", "ctrl-u clear", "ctrl-c quit");
+		else legend.push(options.backLabel === "quit" ? "esc or q quit" : "q quit");
 		lines.push(`${rail}${chalk.dim(legend.join(" · "))}`);
 		frame.draw(lines);
 	};
@@ -294,11 +307,29 @@ export async function promptSelect<T>(options: SelectOptions<T>): Promise<Select
 		output,
 		true,
 		render,
-		(_str, key, finish) => {
+		(str, key, finish) => {
 			if (key.ctrl && (key.name === "c" || key.name === "d")) {
 				finish({ kind: "quit" });
 				return;
 			}
+			if (options.searchable) {
+				if (key.ctrl && key.name === "u") {
+					query = "";
+					filter();
+					return;
+				}
+				if (key.name === "backspace") {
+					query = query.slice(0, -1);
+					filter();
+					return;
+				}
+				if (!key.ctrl && !key.meta && str?.length === 1 && str >= " " && str !== "\x7f") {
+					query += str;
+					filter();
+					return;
+				}
+				if (choices.length === 0 && !["escape", "left"].includes(key.name ?? "")) return;
+			}
 			switch (key.name) {
 				case "up":
 				case "k":

package/src/cli/skills-eval.ts

@@ -133,7 +133,7 @@ interface ScenarioOutcome {
 	usage: ScenarioUsage;
 }
 
-export async function runSkillsEvalCommand(nameOrPath: string, options: SkillsEvalOptions): Promise<number> {
+async function runSkillsEvalCommand(nameOrPath: string, options: SkillsEvalOptions): Promise<number> {
 	const resolved = resolveSkillBaseDir(nameOrPath, process.cwd());
 	if (resolved.baseDir === null) {
 		printError(resolved.error ?? `unknown skill: ${nameOrPath}`);
@@ -149,7 +149,7 @@ export async function runSkillsEvalCommand(nameOrPath: string, options: SkillsEv
 	// attribute to a source is not evidence about a skill, and several roots may
 	// carry this name.
 	process.stderr.write(
-		`clio-coder skills eval: ${skill.name} from ${resolved.origin ?? "unknown"} at ${resolved.baseDir} (sha256 ${skill.normalizedHash.slice(0, 12)}…)\n`,
+		`clio-coder eval skill: ${skill.name} from ${resolved.origin ?? "unknown"} at ${resolved.baseDir} (sha256 ${skill.normalizedHash.slice(0, 12)}…)\n`,
 	);
 	const evalsPath = join(resolved.baseDir, "evals.md");
 	let evalsRaw: string;
@@ -161,7 +161,7 @@ export async function runSkillsEvalCommand(nameOrPath: string, options: SkillsEv
 	}
 	const parsed = parseSkillEvals(evalsRaw);
 	for (const diagnostic of parsed.diagnostics) {
-		process.stderr.write(`clio-coder skills eval: ${diagnostic}\n`);
+		process.stderr.write(`clio-coder eval skill: ${diagnostic}\n`);
 	}
 	const matcher = options.scenario === undefined ? null : scenarioMatcher(options.scenario);
 	if (options.scenario !== undefined && matcher === null) {
@@ -178,7 +178,7 @@ export async function runSkillsEvalCommand(nameOrPath: string, options: SkillsEv
 		return 2;
 	}
 
-	process.stderr.write(`clio-coder skills eval: ${describeArmPolicy(options.allowNetwork)}\n`);
+	process.stderr.write(`clio-coder eval skill: ${describeArmPolicy(options.allowNetwork)}\n`);
 	const childEnv = evalChildEnv(options.allowNetwork);
 	const timeoutMs = options.timeoutSeconds !== undefined ? options.timeoutSeconds * 1000 : DEFAULT_RUN_TIMEOUT_MS;
 	const workspaceOverride = await resolveWorkspaceOverride(options.workspace);
@@ -189,7 +189,7 @@ export async function runSkillsEvalCommand(nameOrPath: string, options: SkillsEv
 	const startedAt = new Date().toISOString();
 	const outcomes: ScenarioOutcome[] = [];
 	for (const scenario of scenarios) {
-		process.stderr.write(`clio-coder skills eval: ${skill.name} ${scenario.id} baseline/treatment/judge...\n`);
+		process.stderr.write(`clio-coder eval skill: ${skill.name} ${scenario.id} baseline/treatment/judge...\n`);
 		outcomes.push(
 			await runScenario(
 				skill.name,
@@ -228,7 +228,7 @@ export async function runSkillsEvalCommand(nameOrPath: string, options: SkillsEv
 		evidenceErrors.push(error instanceof Error ? error.message : String(error));
 	}
 	for (const message of evidenceErrors) {
-		process.stderr.write(`clio-coder skills eval: evidence build failed: ${message}\n`);
+		process.stderr.write(`clio-coder eval skill: evidence build failed: ${message}\n`);
 	}
 
 	if (options.json) {
@@ -1240,3 +1240,40 @@ function readNumber(value: unknown): number {
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+
+/** The experimental evals.md lane stays under eval, alongside package suite evals. */
+export async function runSkillEvalCli(args: ReadonlyArray<string>): Promise<number> {
+	const options: SkillsEvalOptions = { json: false, trustFixtures: false, allowNetwork: false };
+	let source: string | undefined;
+	try {
+		for (let i = 0; i < args.length; i++) {
+			const arg = args[i];
+			if (!arg) continue;
+			if (arg === "--json") options.json = true;
+			else if (arg === "--trust-fixtures") options.trustFixtures = true;
+			else if (arg === "--allow-network") options.allowNetwork = true;
+			else if (["--scenario", "--target", "--workspace", "--timeout"].includes(arg)) {
+				const value = args[++i];
+				if (!value || value.startsWith("-")) throw new Error(`${arg} requires a value`);
+				if (arg === "--timeout") {
+					const seconds = Number(value);
+					if (!Number.isInteger(seconds) || seconds <= 0) throw new Error("--timeout requires a positive integer");
+					options.timeoutSeconds = seconds;
+				} else if (arg === "--scenario") options.scenario = value;
+				else if (arg === "--target") options.target = value;
+				else options.workspace = value;
+			} else if (arg === "--help" || arg === "-h") {
+				process.stdout.write(
+					"clio-coder eval skill <name|path> [--scenario <id>] [--target <id>] [--workspace <path>] [--timeout <seconds>] [--trust-fixtures] [--allow-network] [--json]\n",
+				);
+				return 0;
+			} else if (arg.startsWith("-") || source) throw new Error(`unexpected skill eval argument: ${arg}`);
+			else source = arg;
+		}
+		if (!source) throw new Error("eval skill requires a skill name or path");
+		return await runSkillsEvalCommand(source, options);
+	} catch (error) {
+		printError(error instanceof Error ? error.message : String(error));
+		return 2;
+	}
+}

package/src/cli/skills-inventory.ts

@@ -1,3 +1,4 @@
+import { readSettings } from "../core/config.js";
 /**
  * Fixed machine-readable projection of this installation's installed skills.
  *
@@ -158,7 +159,10 @@ function projectSkill(skill: Skill): SkillsInventorySkill {
 }
 
 function skillsInventorySnapshot(now: () => number = Date.now, cwd: string = process.cwd()): SkillsInventorySnapshot {
-	const list = loadSkills({ cwd });
+	const list = loadSkills({
+		cwd,
+		trustProjectCompatRoots: readSettings().integrations.projectResources.trustProjectImports,
+	});
 	const validity = skillCatalogValidity(list);
 	const projected = list.items.map(projectSkill);
 	const skills = projected.slice(0, MAX_SKILLS_INVENTORY_SKILLS);
@@ -177,7 +181,7 @@ function skillsInventorySnapshot(now: () => number = Date.now, cwd: string = pro
 
 export function runSkillsInventory(args: ReadonlyArray<string>): number {
 	if (args.length !== 1 || args[0] !== "--json") {
-		process.stderr.write("clio-coder skills inventory: usage: clio-coder skills inventory --json\n");
+		process.stderr.write("clio-coder library inventory: usage: clio-coder library inventory --json\n");
 		return 2;
 	}
 	process.stdout.write(`${JSON.stringify(skillsInventorySnapshot(), null, 2)}\n`);