@ejstembler/pi-classifier-router 1.0.0 → 1.0.1

package/README.md

@@ -260,17 +260,47 @@ so it is not a drop-in accuracy replacement for a hosted Jev model.
 
 ## Configuration
 
-Config files are JSON and are searched in this order:
+Config files are searched in this order, project before global and JSON before
+YAML:
 
 1. `<project>/.omp/class-router.json`
-2. `~/.omp/class-router.json`
+2. `<project>/.omp/class-router.yml`
+3. `<project>/.omp/class-router.yaml`
+4. `~/.omp/class-router.json`
+5. `~/.omp/class-router.yml`
+6. `~/.omp/class-router.yaml`
+
+Both formats describe exactly the same configuration, so use whichever you
+prefer:
+
+```yaml
+# ~/.omp/class-router.yml
+backend: jev
+routing:
+  confidenceThreshold: 0.7
+  modelMapping:
+    hard: @slow
+```
+
+```json
+{ "backend": "jev", "routing": { "confidenceThreshold": 0.7, "modelMapping": { "hard": "@slow" } } }
+```
+
+YAML is parsed by the host (`Bun.YAML`), which is free because pi and omp are both
+Bun. A YAML file on a host without a parser is reported as an error rather than
+silently skipped, so a `.yml` that is being ignored is always visible.
 
 These paths are literal and identical on both hosts: the extension discovers its
-own config rather than reading host settings. The first existing file that parses
-and validates wins; a project file therefore overrides a global one. A missing
-file everywhere is not an error: built-in defaults apply. A file that cannot be
-read or parsed is reported and the search continues; a file that parses but
-violates the contract is rejected outright
+own config and never reads host settings. In particular this file is **not**
+omp's `~/.omp/agent/config.yml` (that is omp's own settings: `modelRoles`, theme,
+advisor) and not pi's `~/.pi/agent/settings.json`. They sit alongside each other
+and are unrelated.
+
+The first existing file that parses and validates wins; a project file therefore
+overrides a global one, and a `.json` overrides a `.yml` in the same scope. A
+missing file everywhere is not an error: built-in defaults apply. A file that
+cannot be read or parsed is reported and the search continues; a file that parses
+but violates the contract is rejected outright
 (routing falls back to defaults and the errors are notified), because silent
 mis-routing is worse than leaving the model alone.
 

package/examples/class-router.yml

@@ -0,0 +1,44 @@
+# YAML form of the configuration. Identical in meaning to class-router.json;
+# use whichever you prefer. Copy to ~/.omp/class-router.yml (global) or
+# <project>/.omp/class-router.yml (project-local, which wins).
+#
+# This is the extension's own config file, unrelated to omp's
+# ~/.omp/agent/config.yml or pi's ~/.pi/agent/settings.json.
+
+backend: jev
+
+jev:
+  endpoint: https://api.typesafe.ai/v1/systemone
+  model: jev-latest
+  apiKeyEnvVar: TYPESAFE_API_KEY
+  timeoutMs: 3000
+
+routing:
+  # Must name a choice question: score and noul answers cannot name a category.
+  primaryQuestion: task_complexity
+  # Alias specs are omp-only; on pi use concrete provider/id specs, e.g.
+  # fireworks/accounts/fireworks/routers/deepseek-pro-latest
+  modelMapping:
+    trivial: "@smol"
+    standard: "@default"
+    hard: "@slow"
+  fallbackChains:
+    "@smol":
+      - "@smol"
+      - "@default"
+    "@default":
+      - "@default"
+      - "@slow"
+    "@slow":
+      - "@slow"
+      - "@default"
+  confidenceThreshold: 0.5
+  defaultCategory: standard
+
+circuitBreaker:
+  failureThreshold: 3
+  cooldownMs: 120000
+  halfOpenMaxTrials: 1
+
+notify: true
+applyTo: all

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ejstembler/pi-classifier-router",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/config.ts

@@ -1,10 +1,11 @@
 /**
  * Config discovery, defaults, merge, and validation.
  *
- * Precedence is project over global; the first existing, parseable, valid file
- * wins. A file that fails to read or parse is reported and skipped, but a file
- * that parses yet violates the contract is rejected outright: silently
- * mis-routing is worse than falling back to the session's own model.
+ * Precedence is project over global; within a scope JSON is preferred over YAML.
+ * The first existing, parseable, valid file wins. A file that fails to read or
+ * parse is reported and skipped, but a file that parses yet violates the
+ * contract is rejected outright: silently mis-routing is worse than falling back
+ * to the session's own model.
  */
 
 import * as fs from "node:fs";
@@ -13,9 +14,12 @@ import * as path from "node:path";
 
 import type { Question, RouterConfig, RouterConfigInput } from "./types.ts";
 
+export type ConfigFormat = "json" | "yaml";
+
 export interface ConfigSource {
   path: string;
   scope: "project" | "global";
+  format: ConfigFormat;
 }
 
 export interface ConfigLoadResult {
@@ -24,12 +28,45 @@ export interface ConfigLoadResult {
   errors: string[];
 }
 
-/** Project config first, global config second. */
+/** Parses one YAML document. Supplied by the host, since only Bun has one. */
+export type YamlParser = (text: string) => unknown;
+
+/**
+ * Bun ships a YAML parser; Node does not. Absent a parser, YAML candidates are
+ * reported as errors rather than silently ignored, so a `.yml` config that is
+ * being skipped is visible.
+ */
+export function defaultYamlParser(): YamlParser | null {
+  const scope: unknown = globalThis;
+  if (typeof scope !== "object" || scope === null || !("Bun" in scope)) return null;
+  const bun = scope.Bun;
+  if (typeof bun !== "object" || bun === null || !("YAML" in bun)) return null;
+  const yaml = bun.YAML;
+  if (typeof yaml !== "object" || yaml === null || !("parse" in yaml)) return null;
+  const parse = yaml.parse;
+  if (typeof parse !== "function") return null;
+  // Verified callable just above; only its signature is unknowable statically.
+  const call = parse as (value: string) => unknown;
+  return (text: string) => call(text);
+}
+
+/** Candidate files per scope, in precedence order. */
+const CANDIDATES: ReadonlyArray<{ name: string; format: ConfigFormat }> = [
+  { name: "class-router.json", format: "json" },
+  { name: "class-router.yml", format: "yaml" },
+  { name: "class-router.yaml", format: "yaml" },
+];
+
+/** Every candidate, project first, JSON before YAML, then global. */
 export function configPaths(cwd: string, home: string): ConfigSource[] {
-  return [
-    { path: path.join(cwd, ".omp", "class-router.json"), scope: "project" },
-    { path: path.join(home, ".omp", "class-router.json"), scope: "global" },
-  ];
+  const sources: ConfigSource[] = [];
+  for (const scope of ["project", "global"] as const) {
+    const base = scope === "project" ? cwd : home;
+    for (const candidate of CANDIDATES) {
+      sources.push({ path: path.join(base, ".omp", candidate.name), scope, format: candidate.format });
+    }
+  }
+  return sources;
 }
 
 /** A complete, valid configuration. Fresh objects on every call. */
@@ -242,6 +279,7 @@ export function loadConfig(
   cwd: string,
   home: string = os.homedir(),
   env: Record<string, string | undefined> = process.env,
+  yaml: YamlParser | null = defaultYamlParser(),
 ): ConfigLoadResult {
   void env;
   const errors: string[] = [];
@@ -259,16 +297,33 @@ export function loadConfig(
     }
 
     let parsed: unknown;
-    try {
-      parsed = JSON.parse(raw);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      errors.push(`${source.scope} config ${source.path}: invalid JSON: ${message}`);
-      continue;
+    if (source.format === "yaml") {
+      if (yaml === null) {
+        errors.push(
+          `${source.scope} config ${source.path}: YAML config needs a YAML parser and this host has none ` +
+            `(only Bun provides one); use class-router.json instead`,
+        );
+        continue;
+      }
+      try {
+        parsed = yaml(raw);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        errors.push(`${source.scope} config ${source.path}: invalid YAML: ${message}`);
+        continue;
+      }
+    } else {
+      try {
+        parsed = JSON.parse(raw);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        errors.push(`${source.scope} config ${source.path}: invalid JSON: ${message}`);
+        continue;
+      }
     }
 
     if (!isPlainObject(parsed)) {
-      errors.push(`${source.scope} config ${source.path}: expected a JSON object at the top level`);
+      errors.push(`${source.scope} config ${source.path}: expected a ${source.format === "yaml" ? "YAML" : "JSON"} object at the top level`);
       continue;
     }