agent-lyceum 0.4.9

package/dist/config.js

@@ -0,0 +1,253 @@
+import fs from "node:fs";
+import path from "node:path";
+import YAML from "yaml";
+import { absPath, homePaths, projectPaths, } from "./paths.js";
+import { DISPATCHER_DEFAULTS, GlobalConfig, ProjectConfig, inferRuntime, } from "./schema.js";
+export class ConfigError extends Error {
+}
+function readYaml(file, schema, label) {
+    let text;
+    try {
+        text = fs.readFileSync(file, "utf8");
+    }
+    catch {
+        throw new ConfigError(`${label} not found: ${file}`);
+    }
+    let raw;
+    try {
+        raw = YAML.parse(text) ?? {};
+    }
+    catch (e) {
+        throw new ConfigError(`${label} is not valid YAML (${file}): ${e.message}`);
+    }
+    const parsed = schema.safeParse(raw);
+    if (!parsed.success) {
+        const msg = parsed.error.issues.map((i) => `  - ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n");
+        throw new ConfigError(`${label} is invalid (${file}):\n${msg}`);
+    }
+    return parsed.data;
+}
+export function loadGlobal(home) {
+    const file = homePaths(home).globalConfig;
+    return readYaml(file, GlobalConfig, "Global config");
+}
+export function loadProjectRaw(home, name) {
+    const file = projectPaths(home, name).config;
+    return readYaml(file, ProjectConfig, `Project "${name}" config`);
+}
+function resolveLayer(p, base) {
+    if (!p)
+        return {};
+    const out = { ...p };
+    if (p.agent_md)
+        out.agent_md = absPath(p.agent_md, base);
+    if (p.memory) {
+        out.memory = {};
+        if (p.memory.global)
+            out.memory.global = absPath(p.memory.global, base);
+        if (p.memory.project)
+            out.memory.project = absPath(p.memory.project, base);
+    }
+    return out;
+}
+export function resolveProject(home, name) {
+    const g = loadGlobal(home);
+    const p = loadProjectRaw(home, name);
+    const paths = projectPaths(home, name);
+    const hp = homePaths(home);
+    const lead = p.team.lead;
+    const dispatcher = { ...DISPATCHER_DEFAULTS, ...stripUndef(p.dispatcher) };
+    const agents = {};
+    for (const agentName of Object.keys(p.agents)) {
+        const gl = resolveLayer(g.agents[agentName], home);
+        const pl = resolveLayer(p.agents[agentName], paths.root);
+        const sources = {};
+        const pick = (key) => {
+            if (pl[key] !== undefined) {
+                sources[key] = "project";
+                return pl[key];
+            }
+            if (gl[key] !== undefined) {
+                sources[key] = "global";
+                return gl[key];
+            }
+            return undefined;
+        };
+        const projectAgentMd = path.join(paths.agentsDir, agentName, "AGENT.md");
+        let agentMd = pick("agent_md");
+        if (agentMd === undefined) {
+            if (fs.existsSync(projectAgentMd)) {
+                agentMd = projectAgentMd;
+                sources.agent_md = "project";
+            }
+            else {
+                agentMd = path.join(hp.globalAgentsDir, agentName, "AGENT.md");
+                sources.agent_md = "default";
+            }
+        }
+        const memory = {};
+        if (pl.memory?.global) {
+            memory.global = pl.memory.global;
+            sources["memory.global"] = "project";
+        }
+        else if (gl.memory?.global) {
+            memory.global = gl.memory.global;
+            sources["memory.global"] = "global";
+        }
+        if (pl.memory?.project) {
+            memory.project = pl.memory.project;
+            sources["memory.project"] = "project";
+        }
+        else if (gl.memory?.project) {
+            memory.project = gl.memory.project;
+            sources["memory.project"] = "global";
+        }
+        if (!memory.global && !memory.project) {
+            memory.project = path.join(paths.agentsDir, agentName, "memory");
+            sources["memory.project"] = "default";
+        }
+        const model = pick("model");
+        // Precedence: project runtime > project model > global runtime > global model.
+        // A project-level model must win over an inherited global runtime, or `model: gpt-5` would run on claude.
+        let runtime = pl.runtime;
+        if (runtime !== undefined)
+            sources.runtime = "project";
+        else if ((runtime = inferRuntime(pl.model)))
+            sources.runtime = "model";
+        else if ((runtime = gl.runtime))
+            sources.runtime = "global";
+        else if ((runtime = inferRuntime(gl.model)))
+            sources.runtime = "model";
+        const isLead = agentName === lead;
+        const resume = pick("resume");
+        const canMessage = pick("can_message");
+        const canEdit = pick("can_edit_agent_md");
+        const owns = pick("owns");
+        for (const [k, v] of [
+            ["resume", resume],
+            ["can_message", canMessage],
+            ["can_edit_agent_md", canEdit],
+            ["owns", owns],
+        ]) {
+            if (v === undefined)
+                sources[k] = "default";
+        }
+        agents[agentName] = {
+            name: agentName,
+            runtime,
+            model,
+            effort: pick("effort"),
+            agentMd,
+            memory,
+            resume: resume ?? isLead,
+            canMessage: canMessage ?? (isLead ? "all" : [lead]),
+            canEditAgentMd: canEdit ?? isLead,
+            owns: owns ?? [],
+            sources,
+        };
+    }
+    return {
+        home,
+        name,
+        dir: absPath(p.dir, paths.root),
+        lead,
+        dispatcher,
+        agents,
+        paths,
+    };
+}
+function stripUndef(o) {
+    return Object.fromEntries(Object.entries(o).filter(([, v]) => v !== undefined));
+}
+/** Registered projects: name -> repo dir (best effort; skips broken configs). */
+export function listProjects(home) {
+    const root = homePaths(home).projectsDir;
+    if (!fs.existsSync(root))
+        return [];
+    const out = [];
+    for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        try {
+            const raw = loadProjectRaw(home, entry.name);
+            out.push({ name: entry.name, dir: absPath(raw.dir, projectPaths(home, entry.name).root) });
+        }
+        catch {
+            /* ignore broken project */
+        }
+    }
+    return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+/** Pick the registered project whose dir is the longest prefix of `cwd`. */
+export function findProjectForCwd(home, cwd) {
+    let best;
+    for (const pr of listProjects(home)) {
+        const rel = path.relative(pr.dir, cwd);
+        if (rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel))) {
+            if (!best || pr.dir.length > best.len)
+                best = { name: pr.name, len: pr.dir.length };
+        }
+    }
+    return best?.name;
+}
+const AGENT_FIELDS = ["runtime", "model", "effort", "agent_md", "memory.global", "memory.project", "resume", "can_message", "can_edit_agent_md", "owns"];
+/** The resolved project plus, for every setting, the file and key it was taken from (or "default"). */
+export function resolveProjectWithSources(home, name) {
+    const project = resolveProject(home, name);
+    const raw = loadProjectRaw(home, name);
+    const globalFile = homePaths(home).globalConfig;
+    const projectFile = project.paths.config;
+    const sources = {
+        dir: { file: projectFile, key: "dir" },
+        "team.lead": { file: projectFile, key: "team.lead" },
+    };
+    for (const k of Object.keys(DISPATCHER_DEFAULTS)) {
+        sources[`dispatcher.${k}`] = raw.dispatcher[k] !== undefined ? { file: projectFile, key: `dispatcher.${k}` } : { default: true };
+    }
+    for (const a of Object.values(project.agents)) {
+        const at = (src, field) => {
+            const key = `agents.${a.name}.${field}`;
+            if (src === "project")
+                return { file: projectFile, key };
+            if (src === "global")
+                return { file: globalFile, key };
+            return { default: true };
+        };
+        for (const f of AGENT_FIELDS) {
+            const src = a.sources[f];
+            if (src === undefined)
+                continue; // not set anywhere (e.g. no effort)
+            if (src === "model")
+                sources[`agents.${a.name}.${f}`] = (() => {
+                    const m = at(a.sources.model, "model");
+                    return "file" in m ? { inferred_from: m } : { default: true };
+                })();
+            // A project-level AGENT.md found by convention is not a setting in project.yaml.
+            else if (f === "agent_md" && src === "project" && raw.agents[a.name]?.agent_md === undefined)
+                sources[`agents.${a.name}.${f}`] = { default: true };
+            else
+                sources[`agents.${a.name}.${f}`] = at(src, f);
+        }
+    }
+    return { project, sources };
+}
+/** Every effective setting under the same keys as `resolveProjectWithSources` reports sources for. */
+export function flattenResolved(project) {
+    const v = { dir: project.dir, "team.lead": project.lead };
+    for (const [k, val] of Object.entries(project.dispatcher))
+        v[`dispatcher.${k}`] = val;
+    for (const a of Object.values(project.agents)) {
+        const p = `agents.${a.name}`;
+        v[`${p}.runtime`] = a.runtime;
+        v[`${p}.model`] = a.model;
+        v[`${p}.effort`] = a.effort;
+        v[`${p}.agent_md`] = a.agentMd;
+        v[`${p}.memory.global`] = a.memory.global;
+        v[`${p}.memory.project`] = a.memory.project;
+        v[`${p}.resume`] = a.resume;
+        v[`${p}.can_message`] = a.canMessage;
+        v[`${p}.can_edit_agent_md`] = a.canEditAgentMd;
+        v[`${p}.owns`] = a.owns;
+    }
+    return v;
+}

package/dist/dispatcher.d.ts

@@ -0,0 +1,37 @@
+import { type Invoker } from "./adapters/index.js";
+import type { ResolvedProject } from "./config.js";
+import type { RunOutcome } from "./schema.js";
+import { newRunId, type EndReason, type RunState } from "./run-store.js";
+import { type PreparedTask } from "./task.js";
+export { newRunId };
+export type { ActiveWake, EndReason, RunState, SentTopic, WakeRecord, WakeTopic } from "./run-store.js";
+export declare const RESULT_FILE = "result.md";
+/** How many times a non-conforming `done` goes back to the lead before it is accepted as `partial`. */
+export declare const MAX_DONE_REJECTIONS = 2;
+export interface RunSummary {
+    runId: string;
+    runDir: string;
+    rounds: number;
+    endReason: EndReason;
+    /** How the work turned out; only "completed" means success. */
+    outcome: RunOutcome;
+    outcomeNote?: string;
+    verification?: string;
+    doneMessage?: {
+        subject: string;
+        body: string;
+    };
+}
+export interface RunOptions {
+    project: ResolvedProject;
+    /** The task for a new run; omit when resuming. */
+    task?: PreparedTask;
+    /** Continue this earlier run (same run dir, sessions and counters) instead of starting a new one. */
+    resume?: RunState;
+    runDir: string;
+    invoker?: Invoker;
+    /** Stop the run when this fires: running agents are killed, unread mail is kept, the run ends `cancelled` and can be resumed. */
+    signal?: AbortSignal;
+    log?: (line: string) => void;
+}
+export declare function runTeam(opts: RunOptions): Promise<RunSummary>;