nah-studio 0.0.1-beta.1

package/dist/cli.d.ts

@@ -0,0 +1,13 @@
+export type CliArgs = {
+    help: boolean;
+    version: boolean;
+    port?: number;
+    host?: string;
+    cwd: string;
+    model?: string;
+    dbPath?: string;
+    nahBin?: string;
+    noPublish: boolean;
+};
+/** Hand-rolled, like the CLI it sits beside: a dozen flags do not need a parser. */
+export declare const parseArgs: (argv: string[], env?: NodeJS.ProcessEnv) => CliArgs;

package/dist/cli.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { aI as s } from "./cli-AoWZGiY6.js";
+export {
+  s as parseArgs
+};

package/dist/endpoint.d.ts

@@ -0,0 +1,49 @@
+export type StudioEndpoint = {
+    /** Base URL, e.g. `http://127.0.0.1:4111`. */
+    url: string;
+    /** Required only when the Studio is not bound to loopback. */
+    token?: string;
+    /** The Studio's pid, so a stale file can be told from a live one. */
+    pid: number;
+    startedAt: number;
+    version: string;
+    /**
+     * The `nah` binary that started this Studio, if it was started by one.
+     *
+     * Recorded so the Studio launches the same build the user is running. A global
+     * `nah` from npm and a `nah` built from source produce different traces, and a
+     * dashboard silently watching the wrong one is worse than no dashboard.
+     */
+    nahBin?: string;
+    /** Directory the Studio was pointed at, for the chat tab and experiments. */
+    cwd?: string;
+};
+export declare const endpointPath: (home?: string) => string;
+/**
+ * Read the endpoint, or null when there is not one.
+ *
+ * Never throws: every caller treats a missing or corrupt file as "no Studio",
+ * because a dashboard that cannot start should not be a dashboard that cannot be
+ * read from either.
+ */
+export declare const readEndpoint: (path?: string) => Promise<StudioEndpoint | null>;
+/** Write it atomically, so an agent never reads half a file. */
+export declare const writeEndpoint: (endpoint: StudioEndpoint, path?: string) => Promise<void>;
+/**
+ * Remove it, but only if it is still ours.
+ *
+ * Two Studios on one machine is a mistake, not a scenario; whichever exits first
+ * would otherwise delete the other's file and leave every agent talking to a
+ * closed port.
+ */
+export declare const clearEndpoint: (pid: number, path?: string) => Promise<void>;
+/** Whether a process is still running. Signals 0: exists, and we may signal it. */
+export declare const isProcessAlive: (pid: number) => boolean;
+/**
+ * The Studio to talk to, or null.
+ *
+ * A file whose process is gone is not an endpoint. The alternative is every agent
+ * on the machine retrying a dead port for as long as the file survives, and a
+ * studio the user stopped an hour ago still claiming to be there.
+ */
+export declare const liveEndpoint: (path?: string) => Promise<StudioEndpoint | null>;

package/dist/evals.d.ts

@@ -0,0 +1,82 @@
+import { LanguageModel } from 'ai';
+import { ExperimentResult, ScoreRecord } from './store.js';
+export type ScoreContext = {
+    input: string;
+    expected?: string;
+    output: string;
+    /** Tool names the run called, in order. */
+    toolsCalled: string[];
+    /** Files the run wrote or edited, repo-relative. */
+    filesChanged: string[];
+    traceId?: string;
+};
+export type Scorer = {
+    id: string;
+    name: string;
+    description?: string;
+    /** `rule` needs no model; `judge` needs one. */
+    kind: "rule" | "judge";
+    score(context: ScoreContext): Promise<ScoreRecord>;
+};
+/**
+ * The one rule worth having by default.
+ *
+ * Declined rather than zero when the scorer cannot tell, because a scorer that
+ * returns 0 for "I don't know" drags an average down with numbers that mean
+ * nothing, and the average is the number people quote.
+ */
+export declare const includesScorer: (needles: string[], id?: string) => Scorer;
+export declare const calledToolScorer: (toolName: string, id?: string) => Scorer;
+export declare const mentionsFileScorer: (file: string, id?: string) => Scorer;
+/** Refuses to score a refusal, which is often the correct answer. */
+export declare const notRefusedScorer: (id?: string) => Scorer;
+export declare const JUDGE_SYSTEM = "You score one answer to one question against a rubric.\n\nReply with a single JSON object and nothing else:\n{\"score\": <number between 0 and 1>, \"reason\": \"<one or two sentences, citing the specific part of the answer that decided it>\"}";
+/**
+ * A model grading another model.
+ *
+ * Deliberately plain `generateText` with JSON recovery rather than
+ * `generateObject`, for the same reason the memory extractor is: models without
+ * structured-output support throw `AI_NoObjectGeneratedError`, and a judge that
+ * silently fails every time is a score column full of zeros that reads as "the
+ * agent is bad at this".
+ */
+export declare const judgeScorer: (options: {
+    id: string;
+    name: string;
+    rubric: string;
+    model: LanguageModel;
+    maxOutputTokens?: number;
+}) => Scorer;
+export type RunOneInput = {
+    id: string;
+    input: string;
+    expected?: string;
+};
+/**
+ * Run one dataset item and score it.
+ *
+ * `execute` is supplied by the caller rather than assumed, so the same engine
+ * serves both the CLI (which drives a real session) and a test (which drives a
+ * stub) without a branch here.
+ *
+ * Retried on a provider-level failure. An eval that reports a transient 502 as a
+ * failed agent is worse than one that takes a minute longer: the number gets
+ * quoted, and it is measuring the provider's Tuesday.
+ */
+export declare const runOne: (options: {
+    item: RunOneInput;
+    scorers: Scorer[];
+    execute: (input: RunOneInput) => Promise<{
+        output: string;
+        toolsCalled: string[];
+        filesChanged: string[];
+        traceId?: string;
+    }>;
+}) => Promise<ExperimentResult>;
+/**
+ * Aggregate scores into the shape a comparison needs.
+ *
+ * Skipped scorers are excluded from the mean, and counted separately, so a judge
+ * that failed to answer does not look like a judge that scored badly.
+ */
+export declare const summarize: (results: ExperimentResult[]) => Record<string, unknown>;