@yaag/cli 0.6.2 → 0.8.0

package/src/config/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Public surface of the CLI's `config/` module: Program Directory discovery and
+ * the launcher's Effective Config read (ADR-0040).
+ * Files inside this directory import each other directly.
+ */
+
+export { findProgramDirectory } from "./program-directory.ts";
+export { loadRunConfig, type RunConfigRequest } from "./run-config.ts";

package/src/config/program-directory.ts

@@ -0,0 +1,34 @@
+/**
+ * Program Directory discovery for the launcher.
+ *
+ * The runtime's `config-paths.ts` never walks upward: it takes the Program
+ * Directory as an input. The CLI is the launcher, so the walk lives here
+ * (ADR-0040).
+ */
+import { stat } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { PROJECT_CONFIG_DIR } from "@yaag/runtime";
+
+/**
+ * The nearest directory at or above `startDirectory` that holds a `.yaag`
+ * directory, or `undefined` when the walk reaches the filesystem root.
+ *
+ * A `.yaag` file is not a marker: only a directory can hold a config file.
+ */
+export async function findProgramDirectory(startDirectory: string): Promise<string | undefined> {
+  let directory = resolve(startDirectory);
+  for (;;) {
+    if (await hasMarker(directory)) return directory;
+    const parent = dirname(directory);
+    if (parent === directory) return undefined;
+    directory = parent;
+  }
+}
+
+async function hasMarker(directory: string): Promise<boolean> {
+  try {
+    return (await stat(join(directory, PROJECT_CONFIG_DIR))).isDirectory();
+  } catch {
+    return false;
+  }
+}

package/src/config/run-config.ts

@@ -0,0 +1,54 @@
+/**
+ * The launcher's config read: it resolves the Program Directory of one Run and
+ * loads the Effective Config from the three layers (ADR-0040).
+ *
+ * `RunOptions.config` is read once, here, at Run start. Nothing else in the
+ * process reads a config file.
+ */
+import { dirname, resolve } from "node:path";
+import { type ConfigEnvironment, type EffectiveConfig, loadEffectiveConfig } from "@yaag/runtime";
+import { findProgramDirectory } from "./program-directory.ts";
+
+/** What one Run needs to know to find its config layers. */
+export interface RunConfigRequest {
+  /** Absolute path of the program file; `undefined` for an Inline Program. */
+  readonly programFile: string | undefined;
+  /** Where an Inline Program starts its search; defaults to `process.cwd()`. */
+  readonly cwd?: string;
+  /** The `--config` value, absolute or relative to `cwd`. */
+  readonly configPath?: string;
+  /** `--no-config`: drops the Global and the Project layer only (spec rule 8). */
+  readonly noConfig?: boolean;
+  /** Environment for Global Config discovery; defaults to `process.env`. */
+  readonly env?: ConfigEnvironment;
+}
+
+/**
+ * Loads the Effective Config of one Run.
+ *
+ * The Program Directory search starts at the program file's directory, or at
+ * `cwd` for an Inline Program. `--no-config` skips the search: no discovered
+ * layer can contribute, so nothing must be looked for.
+ *
+ * Throws `YaagError("CONFIG_INVALID", …)` when a config file is missing at the
+ * explicit `--config` path, or when any layer is unreadable or invalid.
+ */
+export async function loadRunConfig(request: RunConfigRequest): Promise<EffectiveConfig> {
+  const cwd = request.cwd ?? process.cwd();
+  const configPath =
+    request.configPath === undefined ? undefined : resolve(cwd, request.configPath);
+  // `--no-config` discovers nothing, so the upward walk is skipped: it would
+  // stat directory after directory for a layer that cannot contribute.
+  const programDirectory =
+    request.noConfig === true
+      ? undefined
+      : await findProgramDirectory(
+          request.programFile === undefined ? cwd : dirname(request.programFile),
+        );
+  return await loadEffectiveConfig({
+    ...(request.env === undefined ? {} : { env: request.env }),
+    ...(request.noConfig === true ? { noConfig: true } : {}),
+    ...(programDirectory === undefined ? {} : { programDirectory }),
+    ...(configPath === undefined ? {} : { configPath }),
+  });
+}

package/src/terminal/render.ts

@@ -39,6 +39,8 @@ function renderPlainEvent(event: LifecycleEventBody, mode: PlainRenderMode): str
         event.maxFrameGapMs === undefined ? "" : ` max gap ${seconds(event.maxFrameGapMs)}`;
       return `[${event.agent}] ask #${event.index + 1} ${event.ok ? "done" : "failed"} ${seconds(event.durationMs)}${gap}`;
     }
+    case "model_fallback":
+      return `[${event.agent}] model ${event.failedModel} ${event.reason} — falling back to ${event.resolvedModel}`;
     case "agent_exit":
       return `[${event.agent}] exit ${tokens(event.tokens)} ${cost(event.cost)}${event.incomplete ? " (killed mid-ask, cost incomplete)" : ""}`;
     case "run_end": {
@@ -58,6 +60,7 @@ function minimalEvent(type: LifecycleEventBody["type"]): boolean {
     type === "agent_spawn" ||
     type === "ask_start" ||
     type === "ask_end" ||
+    type === "model_fallback" ||
     type === "agent_exit" ||
     type === "run_end"
   );

package/src/terminal/run-invocation.ts

@@ -5,7 +5,7 @@
  * Both presentation paths — the plain lines and the alt-screen tree — compose
  * it, so they cannot drift on artifact flags or on the result format.
  */
-import type { RunOptions, StampedEventSink } from "@yaag/runtime";
+import type { EffectiveConfig, RunOptions, StampedEventSink } from "@yaag/runtime";
 
 /** Everything `yaag run` parsed for one Run. */
 export interface RunFlags {
@@ -18,6 +18,8 @@ export interface RunFlags {
   readonly record: string | undefined;
   readonly replay: string | undefined;
   readonly resume: string | undefined;
+  /** The Effective Config the launcher read at Run start (ADR-0040). */
+  readonly config: EffectiveConfig | undefined;
   readonly quiet: boolean;
 }
 
@@ -35,6 +37,7 @@ export function executeOptions(
     ...(flags.record === undefined ? {} : { record: flags.record }),
     ...(flags.replay === undefined ? {} : { replay: flags.replay }),
     ...(flags.resume === undefined ? {} : { resume: flags.resume }),
+    ...(flags.config === undefined ? {} : { config: flags.config }),
     signal,
   };
 }