import { OllamaReplySource, isOllamaModelFlag, parseOllamaModelFlag } from "./coder-ollama.js";

import { openThread, ThreadUnavailable, type ThreadReplySource } from "./coder-thread.js";

import { delegateTool, skillTool } from "./coder-tools.js";

import { discoverSkills } from "./coder-skills.js";

import { loadSkillSelection } from "./coder-skills.js";

import { describeWorkspace } from "./coder-workspace.js";

import { ComputerClient } from "./computer-client.js";

import { ComputerUp } from "./computer-up.js";

      // Skills do not depend on delegation: a session with no credential still

      // reads this repository's conventions, it just cannot hand work to a

      // child. A session with neither declares no tools at all.

      const skills = discoverSkills();

      const tools = [

        ...(skills.length === 0 ? [] : [skillTool(skills)]),

        ...(setup === undefined ? [] : [delegateTool(setup.delegation)]),

      ];

      if (tools.length > 0) {

      const skills = loadSkillSelection();

      // Re-declared rather than declared once: switching a skill off in

      // `/skills` has to change what the next turn carries, and the tool

      // holding the catalog is the thing that changes.

      const declareTools = () => {

        const active = skills.active();

        const tools = [

          ...(active.length === 0 ? [] : [skillTool(active)]),

          ...(setup === undefined ? [] : [delegateTool(setup.delegation)]),

        ];

        source.useTools?.(tools);

      }

      };

      declareTools();

      // Delegation is off rather than quietly running children on the

      // conversation's model, so the refusal that turned it off is what the

      const code = yield* Effect.promise(async () => {

        try {

          return interactive

            ? await runCoderUi(session, { stdin: process.stdin, stdout: process.stdout })

            ? await runCoderUi(session, {

                stdin: process.stdin,

                stdout: process.stdout,

                skills,

                onSkillsChanged: declareTools,

              })

            : await runCoderPlain(session, {

                stdin: process.stdin,

                stdout: process.stdout,

                prompt: oneShot,

                skills,

              });

        } finally {

          // An account holds eight open threads at once. A terminal that closed

import { createInterface } from "node:readline";

import type { CoderEntry, CoderSession } from "./coder-session.js";

import type { SkillSelection } from "./coder-skills.js";

export interface CoderPlainOptions {

  readonly stdin: NodeJS.ReadableStream;

  readonly stdout: NodeJS.WritableStream;

  /** When set, answer this one prompt and exit rather than reading a loop. */

  readonly prompt?: string | undefined;

  /** The workspace's skills, so `/skills` can report them. */

  readonly skills?: SkillSelection | undefined;

}

export async function runCoderPlain(

  flush();

  const answer = async (line: string) => {

    // `/skills` is a screen in the interface. There is no screen here, so it

    // reports instead: the same facts, without the switch. Saying nothing and

    // sending it to the model as a question would be worse than either.

    if (/^\/skills\s*$/.test(line.trim())) {

      const all = options.skills?.all ?? [];

      stdout.write(

        all.length === 0

          ? "\nNo skills were found.\n"

          : `\n${all

              .map(

                (skill) =>

                  `${options.skills?.isOn(skill.name) ?? true ? "[on] " : "[off]"} ${skill.name}`,

              )

              .join("\n")}\nRun the interactive session to switch one.\n`,

      );

      return;

    }

    written = 0;

    stdout.write(`\ncoder> `);

    await session.submit(line);

 * server's. A tool description reaches both.

 */

import { readdirSync, readFileSync, statSync } from "node:fs";

import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";

import { homedir } from "node:os";

import { join } from "node:path";

import { dirname, join } from "node:path";

/** Where skills live, nearest first. A repository skill wins its name. */

const SKILL_DIRECTORIES = (cwd: string, home: string): ReadonlyArray<string> => [

      : skill.body;

  return `Skill \`${skill.name}\` (${skill.path}):\n\n${body}`;

};

/**

 * Which skills this workspace offers the model.

 *

 * A skill costs context whether or not it is used: its description sits in the

 * `skill` tool for the whole session. A reader who knows a skill is irrelevant

 * to today's work should be able to take it out, and have it stay out.

 *

 * The choice is stored per workspace, keyed by path, because the reason to

 * switch a skill off is usually the repository rather than the machine. It is

 * stored under the config directory rather than in the repository so that

 * switching one off is not a change someone else has to review.

 *

 * Off is recorded, not on: a skill added later is on until someone says

 * otherwise, which is the behaviour of a session that has never been touched.

 */

export interface SkillSelection {

  /** Every skill found, switched on or off. */

  readonly all: ReadonlyArray<CoderSkill>;

  /** Whether this skill is offered to the model. */

  isOn(name: string): boolean;

  /** Switch one skill, persist the choice, and return its new state. */

  toggle(name: string): boolean;

  /** The skills the model is offered, in catalog order. */

  active(): ReadonlyArray<CoderSkill>;

}

const selectionPath = (home: string): string =>

  join(home, ".config", "openagents", "coder-skills.json");

/** Names switched off for this workspace, or none when nothing is recorded. */

const readDisabled = (path: string, workspace: string): ReadonlySet<string> => {

  try {

    const parsed = JSON.parse(readFileSync(path, "utf8")) as unknown;

    if (typeof parsed !== "object" || parsed === null) return new Set();

    const entry = (parsed as Record<string, unknown>)[workspace];

    if (!Array.isArray(entry)) return new Set();

    return new Set(entry.filter((name): name is string => typeof name === "string"));

  } catch {

    // No file, unreadable, or not the shape this writes. A preference nobody

    // can read is a preference nobody set, and the session opens with every

    // skill on rather than refusing to start.

    return new Set();

  }

};

const writeDisabled = (path: string, workspace: string, disabled: ReadonlySet<string>): void => {

  let all: Record<string, unknown> = {};

  try {

    const parsed = JSON.parse(readFileSync(path, "utf8")) as unknown;

    if (typeof parsed === "object" && parsed !== null) all = parsed as Record<string, unknown>;

  } catch {

    // Start a fresh file rather than lose the choice being made now.

  }

  // An empty list is the default, so it is removed rather than recorded. A file

  // of empty arrays is a file that says nothing.

  if (disabled.size === 0) delete all[workspace];

  else all[workspace] = [...disabled].sort();

  try {

    mkdirSync(dirname(path), { recursive: true });

    writeFileSync(path, `${JSON.stringify(all, undefined, 2)}\n`, "utf8");

  } catch {

    // The choice still holds for this session. A preference that cannot be

    // written is not a reason to refuse the preference.

  }

};

/** Read the skills for this workspace and the choice made about them. */

export function loadSkillSelection(

  cwd: string = process.cwd(),

  home: string = homedir(),

): SkillSelection {

  const all = discoverSkills(cwd, home);

  const path = selectionPath(home);

  const disabled = new Set(readDisabled(path, cwd));

  return {

    all,

    isOn: (name) => !disabled.has(name),

    toggle: (name) => {

      const on = disabled.has(name);

      if (on) disabled.delete(name);

      else disabled.add(name);

      writeDisabled(path, cwd, disabled);

      return on;

    },

    active: () => all.filter((skill) => !disabled.has(skill.name)),

  };

}

import { fleetPhrase, fleetRows } from "./coder-fleet.js";

import { renderMarkdown, visibleWidth, wrapStyled } from "./coder-markdown.js";

import type { CoderEntry, CoderSession, CoderSnapshot, CoderToolCall } from "./coder-session.js";

import type { SkillSelection } from "./coder-skills.js";

import type { CoderTaskStatus } from "./coder-tasks.js";

const ALT_SCREEN_ON = "\x1b[?1049h";

const ESCAPE_WINDOW_MS = 40;

export interface CoderUiOptions {

  /**

   * The workspace's skills and the choice made about them, for `/skills`.

   *

   * Optional so a caller with no skills, and every test, can leave it out; the

   * screen then says there are none rather than being unreachable.

   */

  readonly skills?: SkillSelection | undefined;

  /** Re-declare the tools after a skill is switched. */

  readonly onSkillsChanged?: (() => void) | undefined;

  readonly stdin: NodeJS.ReadStream;

  readonly stdout: NodeJS.WriteStream;

}

  const { stdin, stdout } = options;

  let composer = "";

  /**

   * Which screen has the keyboard. The chat is the interface; `/skills` is a

   * screen over it rather than a turn in it, because switching a skill off is

   * a change to what the next turn carries, not something to say to the model.

   */

  let screen: "chat" | "skills" = "chat";

  /** The row `/skills` acts on. */

  let skillRow = 0;

  /**

   * The first transcript line the viewport shows, or undefined while the

   * viewport follows the newest content.

      return undefined;

    };

    /**

     * The `/skills` screen: every skill found, and whether the model is told

     * about it.

     *

     * The description is shown because it is the whole of what a switched-on

     * skill costs and the whole of what the model chooses on. A reader deciding

     * whether to keep one needs to see the sentence the model sees.

     */

    const skillsLines = (width: number): ReadonlyArray<string> => {

      const rows: string[] = [];

      const all = options.skills?.all ?? [];

      rows.push(`${BOLD}Skills${RESET}`, "");

      if (all.length === 0) {

        rows.push(

          ...wrapStyled(

            "No skills were found. A skill is a directory holding a SKILL.md, under " +

              ".agents/skills in this repository or under your home directory.",

            width,

            DIM,

          ),

        );

        return rows;

      }

      rows.push(

        ...wrapStyled(

          "Switched-off skills are left out of the tool the model is given, so they cost " +

            "it nothing and it cannot call them. The choice is remembered for this workspace.",

          width,

          DIM,

        ),

        "",

      );

      for (const [at, skill] of all.entries()) {

        const on = options.skills?.isOn(skill.name) ?? true;

        const focused = at === skillRow;

        const mark = on ? `${GREEN}[on] ${RESET}` : `${DIM}[off]${RESET}`;

        const caret = focused ? `${CYAN}❯${RESET} ` : "  ";

        const name = focused ? `${BOLD}${skill.name}${RESET}` : skill.name;

        rows.push(`${caret}${mark} ${on ? name : `${DIM}${skill.name}${RESET}`}`);

        // The description is indented under its own row, dim, and only for the

        // row in hand: eight descriptions at once is the wall of text the

        // catalog exists to avoid.

        if (focused) {

          rows.push(...wrapStyled(skill.description, Math.max(20, width - 8), DIM).map(

            (line) => `        ${line}`,

          ));

        }

      }

      return rows;

    };

    const render = () => {

      if (closed) return;

      const snapshot = session.snapshot();

      const width = stdout.columns ?? 80;

      const height = stdout.rows ?? 24;

      if (screen === "skills") {

        const body = skillsLines(width);

        const rows: string[] = [];

        for (let row = 0; row < Math.max(1, height - 2); row += 1) rows.push(body[row] ?? "");

        rows.push(

          `${DIM}${"─".repeat(Math.max(0, width))}${RESET}`,

          hints(

            [

              { text: "↑↓ move" },

              { text: "space toggles" },

              { text: "esc returns" },

            ],

            "",

            width,

          ),

        );

        // No cursor to place: the screen is a list, not a field.

        paint(rows, rows.length, 1);

        return;

      }

      const transcriptHeight = Math.max(1, height - STATUS_ROWS - COMPOSER_ROWS - 1);

      const fleet = fleetLines(snapshot, width);

      // A delegate line is not a turn: it returns as soon as the children are

      // submitted and each one reports later, so nothing here waits on it and

      // the ticker above keeps the fleet rows moving.

      // `/skills` opens a screen rather than sending a turn: it changes what

      // the next turn carries, so it is not something to say to the model.

      if (/^\/skills\s*$/.test(prompt.trim())) {

        screen = "skills";

        skillRow = 0;

        painted = [];

        render();

        return;

      }

      if (prompt.trimStart().startsWith("/delegate")) {

        void session.submit(prompt);

        render();

      while (index < text.length) {

        const char = text[index] ?? "";

        // The skills screen takes the keyboard while it is up. Only the keys it

        // names do anything: a stray letter must not fall through into the

        // composer of a screen the reader cannot see.

        if (screen === "skills") {

          const count = options.skills?.all.length ?? 0;

          if (char === "\x1b") {

            const sequence = matchEscapeSequence(text, index);

            if (sequence === undefined) {

              pendingEscape = text.slice(index);

              break;

            }

            index += sequence.length;

            if (sequence === "\x1b") {

              screen = "chat";

              painted = [];

            } else if (sequence === "\x1b[A" || sequence === "\x1bOA") {

              skillRow = Math.max(0, skillRow - 1);

            } else if (sequence === "\x1b[B" || sequence === "\x1bOB") {

              skillRow = Math.min(Math.max(0, count - 1), skillRow + 1);

            } else {

              continue;

            }

            render();

            continue;

          }

          index += 1;

          if (char === " ") {

            const skill = options.skills?.all[skillRow];

            if (skill !== undefined) {

              options.skills?.toggle(skill.name);

              // Re-declared now rather than on the next turn, so `/system`

              // agrees with this screen the moment it is left.

              options.onSkillsChanged?.();

            }

            render();

          } else if (char === "\x03" || char === "\x04") {

            screen = "chat";

            painted = [];

            render();

          }

          continue;

        }

        if (char === "\x1b") {

          const sequence = matchEscapeSequence(text, index);

          if (sequence === undefined) {

    session.notice(

      "openagents coder — development build. Type a message and press enter. " +

        "Ctrl+D quits, Esc interrupts a reply. `/system` shows what the model is told.",

        "Ctrl+D quits, Esc interrupts a reply. `/system` shows what the model is told, " +

        "`/skills` chooses which skills it is offered.",

    );

    render();

  });

import { join } from "node:path";

import { describe, expect, it } from "vitest";

import { discoverSkills } from "../src/coder-skills.js";

import { discoverSkills, loadSkillSelection } from "../src/coder-skills.js";

import { skillTool } from "../src/coder-tools.js";

/** A repository with the given skills under `.agents/skills`. */

    expect(output).toContain("`house-style`");

  });

});

describe("choosing which skills the model is offered", () => {

  /** A home the test owns, so the choice is written where it can be read back. */

  const home = () => mkdtempSync(join(tmpdir(), "coder-skills-home-"));

  const two = {

    alpha: "---\nname: alpha\ndescription: First.\n---\n\nBody.",

    beta: "---\nname: beta\ndescription: Second.\n---\n\nBody.",

  };

  it("offers every skill until one is switched off", () => {

    const selection = loadSkillSelection(workspace(two), home());

    expect(selection.active().map((skill) => skill.name)).toEqual(["alpha", "beta"]);

    expect(selection.isOn("alpha")).toBe(true);

  });

  it("drops a switched-off skill from what the model is offered", () => {

    const selection = loadSkillSelection(workspace(two), home());

    selection.toggle("alpha");

    expect(selection.isOn("alpha")).toBe(false);

    expect(selection.active().map((skill) => skill.name)).toEqual(["beta"]);

    // Still found, so the screen can offer to switch it back on.

    expect(selection.all).toHaveLength(2);

  });

  it("remembers the choice for the next session", () => {

    const root = workspace(two);

    const where = home();

    loadSkillSelection(root, where).toggle("beta");

    expect(loadSkillSelection(root, where).active().map((skill) => skill.name)).toEqual(["alpha"]);

  });

  it("switches one back on", () => {

    const root = workspace(two);

    const where = home();

    loadSkillSelection(root, where).toggle("beta");

    loadSkillSelection(root, where).toggle("beta");

    expect(loadSkillSelection(root, where).active().map((skill) => skill.name)).toEqual([

      "alpha",

      "beta",

    ]);

  });

  it("keeps the choice to the workspace it was made in", () => {

    const where = home();

    const one = workspace(two);

    const other = workspace(two);

    loadSkillSelection(one, where).toggle("alpha");

    // A skill switched off for one repository is not switched off everywhere.

    expect(loadSkillSelection(other, where).active().map((skill) => skill.name)).toEqual([

      "alpha",

      "beta",

    ]);

  });

  it("offers a skill added after the choice was made", () => {

    const root = workspace(two);

    const where = home();

    loadSkillSelection(root, where).toggle("alpha");

    mkdirSync(join(root, ".agents", "skills", "gamma"), { recursive: true });

    writeFileSync(

      join(root, ".agents", "skills", "gamma", "SKILL.md"),

      "---\nname: gamma\ndescription: Third.\n---\n\nBody.",

    );

    // Off is what is recorded, so something nobody has ruled on is on.

    expect(loadSkillSelection(root, where).active().map((skill) => skill.name)).toEqual([

      "beta",

      "gamma",

    ]);

  });

});

    expect(composer).toContain("…");

  });

});

describe("the /skills screen", () => {

  const skill = (name: string, description: string) => ({

    name,

    description,

    body: "Body.",

    path: `/tmp/${name}/SKILL.md`,

  });

  /** A selection over two skills, recording what was switched. */

  const selection = () => {

    const off = new Set<string>();

    const all = [skill("alpha", "The first skill."), skill("beta", "The second skill.")];

    return {

      all,

      isOn: (name: string) => !off.has(name),

      toggle: (name: string) => {

        const on = off.has(name);

        if (on) off.delete(name);

        else off.add(name);

        return on;

      },

      active: () => all.filter((candidate) => !off.has(candidate.name)),

    };

  };

  const open = async (skills: ReturnType<typeof selection>) => {

    const stdin = new FakeIn();

    const stdout = new FakeOut();

    const session = new CoderSession(source([]), "repo", "main");

    let declared = 0;

    const running = runCoderUi(session, {

      stdin: stdin as unknown as NodeJS.ReadStream,

      stdout: stdout as unknown as NodeJS.WriteStream,

      skills,

      onSkillsChanged: () => {

        declared += 1;

      },

    });

    // Typed the way a reader types it, then entered.

    stdin.emit("data", "/skills");

    stdin.emit("data", "\r");

    return {

      stdin,

      stdout,

      session,

      running,

      declarations: () => declared,

      rows: () => screen(stdout.written),

      close: async () => {

        stdin.emit("data", "\x1b");

        stdin.emit("data", "\x04");

        await running;

      },

    };

  };

  it("lists every skill with its state, and describes the row in hand", async () => {

    const screenUnderTest = await open(selection());

    const rows = screenUnderTest.rows().join("\n");

    expect(rows).toContain("Skills");

    expect(rows).toContain("[on]  alpha");

    expect(rows).toContain("[on]  beta");

    // The description of the focused row only: eight at once is the wall of

    // text the catalog exists to avoid.

    expect(rows).toContain("The first skill.");

    expect(rows).not.toContain("The second skill.");

    await screenUnderTest.close();

  });

  it("moves the focus with the arrow keys", async () => {

    const screenUnderTest = await open(selection());

    screenUnderTest.stdin.emit("data", "\x1b[B");

    const rows = screenUnderTest.rows().join("\n");

    expect(rows).toContain("The second skill.");

    await screenUnderTest.close();

  });

  it("switches the focused skill with space and re-declares the tools", async () => {

    const skills = selection();

    const screenUnderTest = await open(skills);

    screenUnderTest.stdin.emit("data", " ");

    expect(skills.isOn("alpha")).toBe(false);

    expect(skills.active().map((candidate) => candidate.name)).toEqual(["beta"]);

    // Re-declared at the keystroke, so what the model is told matches the

    // screen the moment it is left.

    expect(screenUnderTest.declarations()).toBe(1);

    expect(screenUnderTest.rows().join("\n")).toContain("[off] alpha");

    await screenUnderTest.close();

  });

  it("sends nothing to the model, on the way in or out", async () => {

    const skills = selection();

    const screenUnderTest = await open(skills);

    screenUnderTest.stdin.emit("data", " ");

    screenUnderTest.stdin.emit("data", "\x1b");

    // `/skills` is a screen, not a turn: no prompt was sent and none was

    // recorded as one.

    expect(screenUnderTest.session.snapshot().turns).toBe(0);

    expect(

      screenUnderTest.session.snapshot().entries.filter((entry) => entry.role === "you"),

    ).toEqual([]);

    screenUnderTest.stdin.emit("data", "\x04");

    await screenUnderTest.running;

  });

  it("holds the keyboard, so typing does not reach the composer behind it", async () => {

    const screenUnderTest = await open(selection());

    screenUnderTest.stdin.emit("data", "hello");

    screenUnderTest.stdin.emit("data", "\x1b");

    const rows = screenUnderTest.rows().join("\n");

    // The letters went nowhere: a screen the reader cannot see must not be

    // collecting what they type.

    expect(rows).not.toContain("hello");

    screenUnderTest.stdin.emit("data", "\x04");

    await screenUnderTest.running;

  });

  it("says so when the workspace has no skills", async () => {

    const stdin = new FakeIn();

    const stdout = new FakeOut();

    const session = new CoderSession(source([]), "repo", "main");

    const running = runCoderUi(session, {

      stdin: stdin as unknown as NodeJS.ReadStream,

      stdout: stdout as unknown as NodeJS.WriteStream,

    });

    stdin.emit("data", "/skills");

    stdin.emit("data", "\r");

    expect(screen(stdout.written).join("\n")).toContain("No skills were found");

    stdin.emit("data", "\x1b");

    stdin.emit("data", "\x04");

    await running;

  });

});