Coding agent

import {
  Displaymanager,
  Glove,
  MemoryStore,
  createAdapter,
  useReadSkill,
  type SubscriberAdapter,
} from "glove-core";
import { loadContentSkillsFromFs } from "glove-core/content-skills-fs";
import { z } from "zod";
// Your code: read_file, write_file, edit_file, grep, bash, git_* as glove-core Tools.
// examples/coding-agent/tools.ts has a complete set to start from.
import { codingTools, readOnlyTools } from "./tools.js";

const DESTRUCTIVE = new Set(["write_file", "edit_file", "bash"]);

export async function createCodingAgent(cwd: string, surface: SubscriberAdapter) {
  const display = new Displaymanager();
  const store = new MemoryStore(`coding:${cwd}`); // tasks + permissions + subagent stores built in

  const agent = new Glove({
    store,
    model: createAdapter({ provider: "anthropic", model: "claude-sonnet-5-5", stream: true }),
    displayManager: display,
    systemPrompt: `You are a coding agent working in ${cwd}.
Explore before you change anything. Track multi-step work with glove_update_tasks.
Run the tests before you say you are done.`,
    compaction_config: {
      max_turns: 50,
      compaction_instructions:
        "Summarise the work. Keep: files changed, task state, failing tests, decisions made.",
    },
  });

  for (const tool of codingTools) {
    agent.fold<any>({
      name: tool.name,
      description: tool.description,
      inputSchema: tool.input_schema,
      // Ask before anything that writes or executes. A function form can
      // exempt read-only shell commands: (input) => !isReadOnly(input.command)
      requiresPermission: DESTRUCTIVE.has(tool.name),
      do: (input) => tool.run(input),
    });
  }

  // A plan the person approves before the agent edits anything.
  agent.fold({
    name: "propose_plan",
    description: "Show a step-by-step plan and wait for the user to approve or change it.",
    inputSchema: z.object({ title: z.string(), steps: z.array(z.string()) }),
    async do(input, display) {
      const decision = await display.pushAndWait({ renderer: "plan_approval", input });
      return { status: "success", data: decision };
    },
  });

  // A read-only explorer the main agent can hand questions to.
  agent.defineSubAgent({
    name: "explorer",
    description: "Answer a question about the codebase by reading files. Never edits.",
    factory: async ({ parentStore, parentControls }) => {
      const child = new Glove({
        store: (await parentStore.createSubAgentStore?.("explorer", false)) ?? new MemoryStore("explorer"),
        model: parentControls.glove.model,
        displayManager: parentControls.displayManager,
        systemPrompt: "Find the answer in the code. Quote paths and line numbers.",
        compaction_config: { compaction_instructions: "Keep the findings." },
      });
      for (const tool of readOnlyTools) {
        child.fold<any>({ name: tool.name, description: tool.description, inputSchema: tool.input_schema, do: (input) => tool.run(input) });
      }
      return child.build();
    },
  });

  agent.addSubscriber(surface); // text_delta, tool_use, tool_use_result, compaction, tokens
  const built = agent.build();

  // Repository guides (.claude/skills/<name>/SKILL.md) as skills the agent reads on demand.
  useReadSkill(built, await loadContentSkillsFromFs(`${cwd}/.claude/skills`));

  return { agent: built, display };
}

const { agent, display } = await createCodingAgent(process.cwd(), terminalSubscriber);
const answered = new Set<string>();

display.subscribe(async (stack) => {
  for (const slot of stack) {
    if (answered.has(slot.id)) continue;
    answered.add(slot.id);
    // Don't await inside the listener: pushAndWait registers its resolver only
    // after every listener returns. Ask on the next tick, then resolve.
    setImmediate(async () => {
      if (slot.renderer === "permission_request") {
        const { toolName, toolInput } = slot.input as { toolName: string; toolInput: unknown };
        display.resolve(slot.id, await confirm(`Allow ${toolName}? ${JSON.stringify(toolInput)}`)); // your prompt
      }
      if (slot.renderer === "plan_approval") {
        display.resolve(slot.id, await reviewPlan(slot.input)); // your prompt
      }
    });
  }
});

const controller = new AbortController();
process.on("SIGINT", () => controller.abort()); // Ctrl-C stops the loop; unAbortable tools finish first
await agent.processRequest("Make the retry test pass", controller.signal);

import { defineAgent } from "glove-foundry";
import { mountSandbox } from "glove-execution";
import { stationSandbox } from "glove-execution/station";
import { StationClient } from "station-client";

export default defineAgent({
  description: "Writes and runs code in a persistent container",
  // model, systemPrompt, store …
  async configure(agent, context) {
    // Your code: the connection the application saved from stationDaemon's onReady,
    // and the sandbox ids this instance was granted on earlier runs.
    const connection = await loadStationConnection();
    const adapter = await stationSandbox({
      client: new StationClient({ url: connection.url, token: connection.token }),
      stationId: connection.stationId,
      sandboxIds: await loadSandboxGrants(context.agentId),
      cleanup: "retain", // keep files and services between runs
    });
    let close = () => adapter.close();
    context.onCleanup(() => close()); // register before anything else can fail
    const sandbox = mountSandbox(agent, { adapter });
    close = () => sandbox.close();
  },
});