kennel 0.2.31 → 0.2.32

package/dist/llm/worker.js

@@ -0,0 +1,866 @@
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
+
+// packages/llm/src/context.ts
+import {
+  closeSync as closeSync2,
+  constants as constants2,
+  fstatSync as fstatSync2,
+  openSync as openSync2,
+  readSync as readSync2,
+  statSync as statSync3
+} from "node:fs";
+import { dirname as dirname3, join as join3, relative as relative2 } from "node:path";
+import local3 from "@raggle-ai/local";
+function unique(values) {
+  return [...new Set(values)];
+}
+function singleLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function gitRoot2(folder) {
+  for (let directory = folder;; directory = dirname3(directory)) {
+    if (statSync3(join3(directory, ".git"), { throwIfNoEntry: false })) {
+      return directory;
+    }
+    if (dirname3(directory) === directory)
+      return;
+  }
+}
+function projectConfigDirectory(folder) {
+  const boundary = gitRoot2(folder) ?? folder;
+  for (let directory = folder;; directory = dirname3(directory)) {
+    const config = statSync3(join3(directory, "raggle.json"), {
+      throwIfNoEntry: false
+    });
+    if (config?.isFile())
+      return directory;
+    if (directory === boundary || dirname3(directory) === directory) {
+      return boundary;
+    }
+  }
+}
+function readProjectConfig(directory) {
+  try {
+    return local3.readRaggleProjectConfig(directory);
+  } catch (error) {
+    throw new Error(`Invalid Raggle config ${join3(directory, "raggle.json")}: ${error.message}`);
+  }
+}
+function readReadmePrefix(worktree) {
+  for (const name of readmeNames) {
+    let fd;
+    try {
+      fd = openSync2(join3(worktree, name), constants2.O_RDONLY | (constants2.O_NONBLOCK ?? 0));
+      if (!fstatSync2(fd).isFile())
+        continue;
+      const buffer = Buffer.alloc(maxReadmeBytes);
+      const bytes = readSync2(fd, buffer, 0, buffer.length, 0);
+      return buffer.toString("utf8", 0, bytes);
+    } catch {} finally {
+      if (fd !== undefined)
+        closeSync2(fd);
+    }
+  }
+  return;
+}
+function firstUsefulParagraph(markdown) {
+  const paragraphs = markdown.replace(/^---\n[\s\S]*?\n---\n/, "").split(/\n\s*\n/);
+  for (const paragraph of paragraphs) {
+    const text = paragraph.split(`
+`).map((line) => line.trim()).filter((line) => line && !line.startsWith("#") && !line.startsWith("```") && !line.startsWith("![") && !line.startsWith("[") && !line.startsWith("<") && !line.startsWith("|") && !/^[-:| ]+$/.test(line)).join(" ").replace(/!\[[^\]]*\]\([^)]*\)/g, "").replace(/\[([^\]]+)\]\([^)]*\)/g, "$1").replace(/[*_`]/g, "").replace(/\s+/g, " ").trim();
+    if (text.length < 20)
+      continue;
+    return text.length > maxSummaryLength ? `${text.slice(0, maxSummaryLength - 1).trimEnd()}…` : text;
+  }
+  return;
+}
+function projectSummary(project) {
+  const description = singleLine(project.description ?? "");
+  if (description)
+    return description;
+  const readme = readReadmePrefix(project.repositoryRoot ?? project.worktree);
+  return readme ? firstUsefulParagraph(readme) : undefined;
+}
+function repositoryLabel(project) {
+  const remoteUrl = project.remoteMismatch?.actualRemoteUrl ?? project.remoteUrl;
+  const browserUrl = remoteUrl ? local3.remoteToBrowserUrl(remoteUrl) ?? remoteUrl : undefined;
+  const worktree = canonicalPath(project.worktree);
+  return browserUrl ? `${worktree} (${browserUrl})` : worktree;
+}
+function repositoryKeys(project) {
+  return [
+    project.remoteMismatch?.actualRemoteUrl,
+    project.remoteUrl,
+    ...project.relatedIds ?? []
+  ].flatMap((url) => {
+    const key = url ? local3.repositoryLocationKey(url) : undefined;
+    return key ? [key] : [];
+  });
+}
+function isOrganisationKey(key) {
+  const parts = key.split("/");
+  return parts.length === 2 && (parts[0] === "github.com" || Boolean(parts[0]?.endsWith(".github.com")));
+}
+function missingLinks(config, connected) {
+  const selected = canonicalPath(connected.selectedWorktree);
+  const direct = config.linkedRepositories.filter((entry) => canonicalPath(entry.project) === selected);
+  if (!direct.length)
+    return [];
+  const present = new Set([...connected.linked, ...connected.linking, ...connected.local].flatMap(repositoryKeys));
+  return direct.filter(({ repository }) => {
+    const key = local3.repositoryLocationKey(repository);
+    return Boolean(key) && !isOrganisationKey(key) && !present.has(key);
+  });
+}
+function relationHeading(type) {
+  if (type === "notes")
+    return "Non-code project material";
+  if (type === "implementation")
+    return "Implementations";
+  if (type === "dependency")
+    return "Dependencies";
+  return "Linked folders";
+}
+function treeLines(root, projects, relations, direction, type, reasons) {
+  const projectByWorktree = new Map(projects.map((project) => [canonicalPath(project.worktree), project]));
+  const children = new Map;
+  for (const relation of relations) {
+    const parent = direction === "linked" ? relation.source : relation.target;
+    const child = direction === "linked" ? relation.target : relation.source;
+    if (!projectByWorktree.has(child))
+      continue;
+    const items = children.get(parent) ?? [];
+    if (!items.some((item) => item.source === relation.source && item.target === relation.target && item.type === relation.type)) {
+      items.push(relation);
+    }
+    children.set(parent, items);
+  }
+  const lines = [];
+  const visited = new Set;
+  const append = (parent, indent, allowedType, parentType) => {
+    const byType = new Map;
+    for (const relation of children.get(parent) ?? []) {
+      if (allowedType && relation.type !== allowedType)
+        continue;
+      byType.set(relation.type, [
+        ...byType.get(relation.type) ?? [],
+        relation
+      ]);
+    }
+    for (const [relationType, childRelations] of byType) {
+      const showHeading = !allowedType && relationType !== parentType;
+      if (showHeading) {
+        lines.push(`${"  ".repeat(indent)}${relationHeading(relationType)}:`);
+      }
+      const childIndent = showHeading ? indent + 1 : indent;
+      const detail = "  ".repeat(childIndent + 1);
+      for (const relation of childRelations) {
+        const child = direction === "linked" ? relation.target : relation.source;
+        if (visited.has(child))
+          continue;
+        visited.add(child);
+        const project = projectByWorktree.get(child);
+        if (!project)
+          continue;
+        lines.push(`${"  ".repeat(childIndent)}- ${repositoryLabel(project)}`);
+        const summary = projectSummary(project);
+        if (summary)
+          lines.push(`${detail}Description: ${summary}`);
+        const reason = singleLine(reasons.get(child) ?? "");
+        if (reason)
+          lines.push(`${detail}Relation note: ${reason}`);
+        append(child, childIndent + 1, undefined, relationType);
+      }
+    }
+  };
+  append(canonicalPath(root), 0, type);
+  return lines;
+}
+function localSubpathName(folder, project) {
+  return project.relativePath || relative2(canonicalPath(folder), canonicalPath(project.worktree));
+}
+function modeLabel(depth) {
+  if (depth === "full")
+    return "full (all reachable links)";
+  return `expanded to depth ${depth}`;
+}
+async function buildCoreContext(options) {
+  const { folder, depth, signal } = options;
+  const configDirectory = projectConfigDirectory(folder);
+  const config = readProjectConfig(configDirectory);
+  const connected = await local3.mergePersonalRelations(folder, await local3.listConnectedProjects(folder, {
+    depth
+  }));
+  signal.throwIfAborted();
+  const selected = canonicalPath(connected.selectedWorktree);
+  const reasons = connected.personalReasons;
+  const tree = (projects, direction, type) => treeLines(selected, projects, connected.relations, direction, type, reasons);
+  const related = [
+    ...tree(connected.linked, "linked", "related"),
+    ...tree(connected.linking, "linking", "related")
+  ];
+  const implementations = [
+    ...tree(connected.linked, "linked", "implementation"),
+    ...tree(connected.linking, "linking", "implementation"),
+    ...tree(connected.linked, "linked", "notes")
+  ];
+  const dependencies = tree(connected.linked, "linked", "dependency");
+  const dependents = tree(connected.linking, "linking", "dependency");
+  const linkedKeys = new Set(connected.linked.map((project) => canonicalPath(project.worktree)));
+  const localSubpaths = connected.local.filter((project) => !linkedKeys.has(canonicalPath(project.worktree))).map((project) => localSubpathName(folder, project)).filter((name) => name && name !== ".");
+  const missing = missingLinks(config, connected);
+  const configFile = join3(configDirectory, "raggle.json");
+  const blocks = [
+    [
+      "## Folder",
+      "",
+      `- Path: ${folder}`,
+      ...selected !== folder ? [`- Raggle project: ${selected}`] : [],
+      ...statSync3(configFile, { throwIfNoEntry: false })?.isFile() ? [`- Raggle config: ${configFile}`] : [],
+      `- Context: ${modeLabel(depth)}`
+    ].join(`
+`)
+  ];
+  const groups = [
+    ["Linked folders", related],
+    ["Implementations", implementations],
+    ["Dependencies", dependencies],
+    ["Dependents", dependents],
+    ["Key local subpaths", localSubpaths.map((name) => `- ${name}`)]
+  ];
+  const hasLocations = groups.some(([, lines]) => lines.length > 0);
+  if (hasLocations) {
+    blocks.push([
+      "## Local code locations",
+      "",
+      "These repositories are already resolved to local checkouts. Use the paths below directly. Do not search for another checkout or clone these repositories again.",
+      ...groups.flatMap(([label, lines]) => lines.length ? ["", `${label}:`, "", ...lines] : [])
+    ].join(`
+`));
+    blocks.push([
+      "## Working with this code",
+      "",
+      `- Read and search within the listed roots using absolute paths. Local subpaths are relative to ${folder}.`,
+      "- Read each repository's applicable agent instructions before editing.",
+      "- Edit files at their actual paths, not through .rgl/links mirrors.",
+      '- Run tests and Git commands in the repository being changed (for example: git -C "/absolute/repository/path" status).',
+      "- If a path is missing or access is denied, report it; do not silently choose another checkout."
+    ].join(`
+`));
+  }
+  if (missing.length) {
+    blocks.push([
+      "## Not available locally",
+      "",
+      ...missing.map(({ repository, type }) => `- ${repository} (${type}): no local checkout resolved. Ask before cloning or selecting a different location.`)
+    ].join(`
+`));
+  }
+  if (!hasLocations && !missing.length) {
+    blocks.push([
+      "## Links",
+      "",
+      `No linked repositories, notes folders, or subprojects were found for ${folder}.`,
+      "Declare related repositories in the project's raggle.json to add their local paths and descriptions to this context."
+    ].join(`
+`));
+  }
+  const linkedFolders = unique(connected.relations.filter((relation) => relation.type === "notes" && relation.origin !== "organisation" && (canonicalPath(relation.target) === selected || canonicalPath(relation.source) === selected)).map((relation) => canonicalPath(relation.target) === selected ? canonicalPath(relation.source) : canonicalPath(relation.target))).filter((path) => path !== folder && Boolean(statSync3(path, { throwIfNoEntry: false })?.isDirectory()));
+  return { blocks, linkedFolders };
+}
+var canonicalPath, readmeNames, maxReadmeBytes, maxSummaryLength = 280;
+var init_context = __esm(() => {
+  ({ canonicalPath } = local3);
+  readmeNames = ["README.md", "README.markdown", "README", "readme.md"];
+  maxReadmeBytes = 16 * 1024;
+});
+
+// packages/llm/src/plugins.ts
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function checkLines(name, lines, fail) {
+  let fence;
+  for (const [index, line] of lines.entries()) {
+    const where = `${name} line ${index + 1}`;
+    if (CONTROL.test(line)) {
+      fail(`${where} contains a line break or control character`);
+    }
+    const marker = FENCE.exec(line)?.[1];
+    if (fence) {
+      if (marker && marker[0] === fence[0] && marker.length >= fence.length && line.trim() === marker) {
+        fence = undefined;
+      }
+      continue;
+    }
+    if (marker) {
+      fence = marker;
+      continue;
+    }
+    if (HEADING.test(line))
+      fail(`${where} is a heading; the host owns headings`);
+    if (SETEXT_UNDERLINE.test(line) && index > 0 && lines[index - 1]?.trim()) {
+      fail(`${where} would make the line before it a heading`);
+    }
+  }
+  if (fence)
+    fail(`${name} leaves a code fence open`);
+}
+function validateSections(plugin, output) {
+  const fail = (detail) => {
+    throw new Error(`Plugin ${plugin} returned invalid LLM context: ${detail}`);
+  };
+  if (!Array.isArray(output))
+    fail("expected an array of sections");
+  const ids = new Set;
+  const sections = [];
+  for (const [index, value] of output.entries()) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      fail(`section ${index + 1} is not an object`);
+    }
+    const { id, title, lines } = value;
+    if (typeof id !== "string" || !SECTION_ID.test(id)) {
+      fail(`section ${index + 1} needs an id of lowercase letters, digits, "-", or "_"`);
+    }
+    const name = `section ${plugin}/${id}`;
+    if (ids.has(id))
+      fail(`${name} is duplicated`);
+    ids.add(id);
+    if (typeof title !== "string" || !title.trim()) {
+      fail(`${name} needs a non-blank title`);
+    }
+    if (CONTROL.test(title)) {
+      fail(`${name} title contains a line break or control character`);
+    }
+    if (!Array.isArray(lines) || !lines.every((line) => typeof line === "string")) {
+      fail(`${name} lines must be an array of strings`);
+    }
+    const text = lines.map((line) => line.trim() ? line : "");
+    checkLines(name, text, fail);
+    const first = text.findIndex(Boolean);
+    if (first === -1)
+      continue;
+    let end = text.length;
+    while (!text[end - 1])
+      end -= 1;
+    sections.push({
+      id,
+      title: title.trim(),
+      lines: text.slice(first, end)
+    });
+  }
+  return sections;
+}
+async function runContributors(contributors, context) {
+  const contributions = [];
+  const seen = new Set;
+  for (const contributor of contributors) {
+    if (seen.has(contributor.id)) {
+      throw new Error(`Duplicate plugin id ${contributor.id}`);
+    }
+    seen.add(contributor.id);
+    const label = typeof contributor.label === "string" ? contributor.label.trim() : "";
+    if (!label || CONTROL.test(label)) {
+      throw new Error(`Plugin ${contributor.id} has an invalid label`);
+    }
+    context.signal.throwIfAborted();
+    let output;
+    try {
+      output = await contributor.llm({
+        folder: context.folder,
+        linkedFolders: [...context.linkedFolders],
+        signal: context.signal
+      });
+    } catch (error) {
+      throw new Error(`Plugin ${contributor.id} failed to provide LLM context: ${message(error)}`);
+    }
+    context.signal.throwIfAborted();
+    const sections = validateSections(contributor.id, output);
+    if (sections.length) {
+      contributions.push({ id: contributor.id, label, sections });
+    }
+  }
+  return contributions;
+}
+var SECTION_ID, CONTROL, HEADING, SETEXT_UNDERLINE, FENCE;
+var init_plugins = __esm(() => {
+  SECTION_ID = /^[a-z0-9][a-z0-9_-]{0,63}$/u;
+  CONTROL = /[\u0000-\u001f\u007f-\u009f\u2028\u2029]/u;
+  HEADING = /^ {0,3}#{1,6}(?: |$)/u;
+  SETEXT_UNDERLINE = /^ {0,3}(?:=+|-+) *$/u;
+  FENCE = /^ {0,3}(`{3,}|~{3,})/u;
+});
+
+// packages/llm/src/index.ts
+import { realpathSync as realpathSync2, statSync as statSync4 } from "node:fs";
+
+// packages/llm/src/agents.ts
+import { statSync as statSync2 } from "node:fs";
+import { dirname as dirname2, isAbsolute, join as join2, relative, sep } from "node:path";
+import local2 from "@raggle-ai/local";
+
+// packages/llm/src/instructions.ts
+import {
+  closeSync,
+  constants,
+  fstatSync,
+  lstatSync,
+  openSync,
+  readSync,
+  realpathSync,
+  statSync
+} from "node:fs";
+import { dirname, join } from "node:path";
+import { TextDecoder } from "node:util";
+import local from "@raggle-ai/local";
+function readInstructionSettings() {
+  return local.readAgentInstructionSettings();
+}
+function assertProfileName(profile) {
+  if (!local.agentProfileSchema.safeParse(profile).success) {
+    throw new Error(`Invalid profile "${profile}": use lowercase letters, digits, hyphens, or underscores (at most 64 characters)`);
+  }
+  return profile;
+}
+function missing(error) {
+  return error.code === "ENOENT";
+}
+function checkedPath(base, segments) {
+  let current = base;
+  for (const [index, segment] of segments.entries()) {
+    current = join(current, segment);
+    const directory = index < segments.length - 1;
+    const info = lstatSync(current, { throwIfNoEntry: false });
+    if (info?.isSymbolicLink()) {
+      throw new Error(`Refusing instruction symlink: ${current}`);
+    }
+    if (info && (directory ? !info.isDirectory() : !info.isFile())) {
+      throw new Error(`Expected an instruction ${directory ? "directory" : "file"}: ${current}`);
+    }
+  }
+  return current;
+}
+function readInstructionFile(file, maxBytes) {
+  let fd;
+  try {
+    fd = openSync(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  } catch (error) {
+    if (missing(error))
+      return;
+    throw new Error(`Cannot read instructions at ${file}: ${error.message}`);
+  }
+  try {
+    const tooLarge = () => new Error(`Instructions exceed the ${maxBytes}-byte remaining budget: ${file}. Shorten the file or raise agentInstructions.maxBytes in the Raggle settings.`);
+    if (!fstatSync(fd).isFile()) {
+      throw new Error(`Not an instruction file: ${file}`);
+    }
+    if (fstatSync(fd).size > maxBytes)
+      throw tooLarge();
+    const buffer = Buffer.alloc(maxBytes + 1);
+    let bytes = 0;
+    while (bytes < buffer.length) {
+      const count = readSync(fd, buffer, bytes, buffer.length - bytes, null);
+      if (!count)
+        break;
+      bytes += count;
+    }
+    if (bytes > maxBytes)
+      throw tooLarge();
+    let content;
+    try {
+      content = new TextDecoder("utf-8", { fatal: true }).decode(buffer.subarray(0, bytes));
+    } catch {
+      throw new Error(`Instructions must be UTF-8 text: ${file}`);
+    }
+    if (content.includes("\x00")) {
+      throw new Error(`Instructions contain NUL bytes: ${file}`);
+    }
+    return { path: file, content, bytes };
+  } finally {
+    closeSync(fd);
+  }
+}
+function readRepositoryInstructions(folder, maxBytes) {
+  for (const name of ["AGENTS.md", "agents.md"]) {
+    const read = readInstructionFile(checkedPath(folder, [name]), maxBytes);
+    if (read)
+      return read;
+  }
+  return;
+}
+function instructionProjectRoot(folder) {
+  const start = realpathSync(folder);
+  let configRoot;
+  for (let directory = start;; directory = dirname(directory)) {
+    const config = statSync(join(directory, "raggle.json"), {
+      throwIfNoEntry: false
+    });
+    if (!configRoot && config?.isFile())
+      configRoot = directory;
+    if (lstatSync(join(directory, ".git"), { throwIfNoEntry: false })) {
+      return configRoot ?? directory;
+    }
+    if (dirname(directory) === directory)
+      return configRoot ?? start;
+  }
+}
+function readPersonalInstructions(folder, settings, profile) {
+  const selected = assertProfileName(profile ?? settings.defaultProfile);
+  const root = instructionProjectRoot(folder);
+  const configDirectory = dirname(local.raggleUserSettingsPath());
+  const scopes = settings.includeGlobal ? ["global", "project"] : ["project"];
+  const sources = [];
+  let totalBytes = 0;
+  for (const scope of scopes) {
+    for (const name of new Set(["default", selected])) {
+      const file = scope === "global" ? checkedPath(configDirectory, ["agents", "instructions", `${name}.md`]) : checkedPath(root, [".rgl", "agent", `${name}.md`]);
+      const read = readInstructionFile(file, settings.maxBytes - totalBytes);
+      if (!read)
+        continue;
+      totalBytes += read.bytes;
+      const content = read.content.trim();
+      if (content) {
+        sources.push({ scope, profile: name, path: read.path, content });
+      }
+    }
+  }
+  return { root, sources };
+}
+
+// packages/llm/src/agents.ts
+function exists(folder) {
+  return Boolean(statSync2(folder, { throwIfNoEntry: false })?.isDirectory());
+}
+function inside(folder, root) {
+  const path = relative(root, folder);
+  return path === "" || !isAbsolute(path) && path !== ".." && !path.startsWith(`..${sep}`);
+}
+function gitRoot(folder) {
+  for (let root = folder;; root = dirname2(root)) {
+    if (statSync2(join2(root, ".git"), { throwIfNoEntry: false }))
+      return root;
+    if (dirname2(root) === root)
+      return;
+  }
+}
+function configFolders(roots, boundary) {
+  const folders = new Set;
+  for (const root of roots) {
+    if (!exists(root))
+      continue;
+    const start = local2.canonicalPath(root);
+    for (let folder = start;; folder = dirname2(folder)) {
+      if (statSync2(join2(folder, "raggle.json"), {
+        throwIfNoEntry: false
+      })?.isFile()) {
+        folders.add(folder);
+      }
+      if (folder === boundary || dirname2(folder) === folder)
+        break;
+    }
+  }
+  return [...folders];
+}
+async function buildAgentContext(options) {
+  const { folder, signal } = options;
+  const settings = local2.readRaggleUserSettings();
+  const checkout = gitRoot(folder);
+  let remote;
+  if (checkout) {
+    try {
+      remote = await local2.gitRemoteUrl(checkout);
+    } catch (error) {
+      if (error.code !== 2)
+        throw error;
+    }
+  }
+  const identities = new Set;
+  const addIdentity = (repository) => {
+    const key = local2.repositoryLocationKey(repository);
+    if (key)
+      identities.add(key);
+  };
+  if (remote)
+    addIdentity(remote);
+  for (const [repository, location] of Object.entries(settings.repositoryLocations)) {
+    const preferred = local2.canonicalPath(location.preferredWorktree);
+    if (exists(preferred) && checkout && gitRoot(preferred) === checkout) {
+      addIdentity(repository);
+    }
+  }
+  const roots = [
+    folder,
+    ...settings.projectDirectories,
+    ...Object.values(settings.repositoryLocations).map((entry) => entry.preferredWorktree),
+    ...local2.getResolvedWorkspaces().map((entry) => entry.worktree),
+    ...settings.baseRepository ? [settings.baseRepository] : []
+  ];
+  const organisations = new Set;
+  const notes = new Set;
+  const projectNotes = new Set;
+  const matches = (repository) => {
+    const key = local2.repositoryLocationKey(repository);
+    return Boolean(key && identities.has(key));
+  };
+  const configErrors = new Map;
+  for (const owner of configFolders(roots)) {
+    signal.throwIfAborted();
+    let config;
+    try {
+      config = local2.readRaggleProjectConfig(owner);
+    } catch (error) {
+      configErrors.set(owner, error);
+      continue;
+    }
+    const matchingOrganisations = config.linkedOrganisations.filter((entry) => {
+      const key = local2.repositoryLocationKey(entry.organisation);
+      return key && [...identities].some((identity) => identity.startsWith(`${key}/`));
+    });
+    for (const entry of matchingOrganisations) {
+      if (exists(entry.project))
+        organisations.add(local2.canonicalPath(entry.project));
+    }
+    for (const entry of config.linkedRepositories) {
+      if (!matches(entry.repository) || !exists(entry.project))
+        continue;
+      const source = local2.canonicalPath(entry.project);
+      if (entry.type === "notes")
+        notes.add(source);
+      if (entry.type === "implementation" && matchingOrganisations.some((org) => inside(source, org.project))) {
+        projectNotes.add(source);
+      }
+    }
+  }
+  const destination = [...notes][0] ?? [...projectNotes][0];
+  const sources = new Set;
+  const addChain = (source, boundary) => {
+    for (const ancestor of configFolders([source], boundary).reverse())
+      sources.add(ancestor);
+    sources.add(source);
+  };
+  const outerOrganisations = [...organisations].filter((source) => ![...organisations].some((parent) => parent !== source && inside(source, parent)));
+  for (const source of outerOrganisations)
+    addChain(source);
+  if (destination)
+    addChain(destination);
+  if (checkout)
+    sources.add(checkout);
+  if (folder !== checkout)
+    addChain(folder, checkout);
+  const requiredConfigs = new Set([
+    ...configFolders([folder], checkout),
+    ...sources
+  ]);
+  for (const [owner, error] of configErrors) {
+    if (requiredConfigs.has(owner)) {
+      throw new Error(`Invalid Raggle config ${join2(owner, "raggle.json")}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  const blocks = [];
+  let remainingBytes = options.instructionBytes;
+  if (remainingBytes !== undefined) {
+    for (const source of sources) {
+      signal.throwIfAborted();
+      const instruction = readRepositoryInstructions(source, remainingBytes);
+      if (!instruction)
+        continue;
+      remainingBytes -= instruction.bytes;
+      if (instruction.content.trim())
+        blocks.push(instruction.content.trim());
+    }
+  }
+  if (destination && destination !== folder) {
+    blocks.push(`Write any planning or research content you create during this session (markdown, html files etc) to ${destination}`);
+  }
+  return {
+    blocks,
+    linkedFolders: [...new Set([...notes, ...projectNotes])].filter((path) => path !== folder)
+  };
+}
+
+// packages/llm/src/format.ts
+function personalInstructionsBlock(personal) {
+  if (!personal.sources.length)
+    return;
+  return [
+    "## Personal agent instructions",
+    "",
+    `Supplemental instructions for ${personal.root}. Repository AGENTS.md instructions still apply. These files are included as text, not executed.`,
+    ...personal.sources.flatMap((source) => [
+      "",
+      `### ${source.scope}: ${source.profile}`,
+      `Source: ${source.path}`,
+      "",
+      source.content
+    ])
+  ].join(`
+`);
+}
+function pluginContextBlock(contributions) {
+  if (!contributions.length)
+    return;
+  return [
+    "## Plugin context",
+    ...contributions.flatMap((plugin) => [
+      "",
+      `### ${plugin.label} (${plugin.id})`,
+      ...plugin.sections.flatMap((section) => [
+        "",
+        `#### ${section.title}`,
+        ...section.lines
+      ])
+    ])
+  ].join(`
+`);
+}
+function renderMessage(blocks) {
+  const text = blocks.map((block) => block?.trim()).filter(Boolean).join(`
+
+`);
+  return text ? `${text}
+` : "";
+}
+
+// packages/llm/src/index.ts
+var MAX_CONTEXT_BYTES = 1024 * 1024;
+function realDirectory(folder) {
+  let path;
+  try {
+    path = realpathSync2(folder);
+  } catch {
+    throw new Error(`Folder does not exist: ${folder}`);
+  }
+  if (!statSync4(path).isDirectory())
+    throw new Error(`Not a folder: ${folder}`);
+  return path;
+}
+async function buildLlmContext(options) {
+  const signal = options.signal ?? new AbortController().signal;
+  const includeInstructions = options.includeInstructions !== false;
+  const { depth, profile } = options;
+  if (depth !== undefined && depth !== "full" && !(Number.isSafeInteger(depth) && depth > 0)) {
+    throw new Error(`Depth must be a positive integer or "full": ${depth}`);
+  }
+  if (profile !== undefined) {
+    if (!includeInstructions) {
+      throw new Error("A profile cannot be used when instructions are omitted");
+    }
+    assertProfileName(profile);
+  }
+  signal.throwIfAborted();
+  const folder = realDirectory(options.folder);
+  const settings = includeInstructions ? readInstructionSettings() : undefined;
+  const agents = settings || depth !== undefined ? await buildAgentContext({
+    folder,
+    instructionBytes: settings?.maxBytes,
+    signal
+  }) : { blocks: [], linkedFolders: [] };
+  let blocks = agents.blocks;
+  let pluginBlock;
+  if (depth !== undefined) {
+    await Promise.resolve().then(() => init_context());
+    await Promise.resolve().then(() => init_plugins());
+    const core = await buildCoreContext({
+      folder,
+      depth,
+      signal
+    });
+    const contributions = await runContributors(options.plugins ?? [], {
+      folder,
+      linkedFolders: [
+        ...new Set([...agents.linkedFolders, ...core.linkedFolders])
+      ],
+      signal
+    });
+    blocks = [...agents.blocks, ...core.blocks];
+    pluginBlock = pluginContextBlock(contributions);
+  }
+  const personal = settings ? readPersonalInstructions(folder, settings, profile) : undefined;
+  const text = renderMessage([
+    ...blocks,
+    personal && (depth === undefined ? personal.sources.map((source) => source.content).join(`
+
+`) : personalInstructionsBlock(personal)),
+    pluginBlock
+  ]);
+  const bytes = Buffer.byteLength(text, "utf8");
+  if (bytes > MAX_CONTEXT_BYTES) {
+    throw new Error(`The context message is ${bytes} bytes, over the ${MAX_CONTEXT_BYTES}-byte limit. It is not truncated. Use the default agent-only mode, --no-instructions, or --no-plugins.`);
+  }
+  return text;
+}
+
+// packages/cli/src/llm/worker.ts
+function send(message) {
+  return new Promise((resolve) => {
+    if (!process.send)
+      return resolve();
+    process.send(message, undefined, {}, () => resolve());
+  });
+}
+function installed(path) {
+  return import(new URL(path, import.meta.url).href);
+}
+async function contributors(folder) {
+  await send({ type: "stage", stage: "installed plugin loading" });
+  const external = await installed("../plugins/external.js");
+  external.usePluginBuild(await external.readPluginBuild());
+  const server = await installed("../site/server-plugins.js");
+  const registry = server.configuredFolderServerRegistry(await server.folderServerRegistryAsync(), await server.folderPluginRegistryConfig(folder));
+  return [...registry.values()].flatMap((plugin) => {
+    if (plugin.llm === undefined)
+      return [];
+    if (typeof plugin.llm !== "function")
+      throw new Error(`Plugin ${plugin.id} llm hook is not a function`);
+    const hook = plugin.llm.bind(plugin);
+    return [{
+      id: plugin.id,
+      label: plugin.label,
+      llm: (context) => {
+        send({ type: "stage", stage: `the ${plugin.id} plugin llm hook` });
+        return hook(context);
+      }
+    }];
+  });
+}
+function reportUnhandledFailure(error) {
+  send({
+    type: "result",
+    ok: false,
+    error: error instanceof Error ? error.message : String(error)
+  }).finally(() => process.exit(1));
+}
+process.once("uncaughtException", reportUnhandledFailure);
+process.once("unhandledRejection", reportUnhandledFailure);
+async function main() {
+  const request = JSON.parse(process.argv[2] ?? "");
+  const controller = new AbortController;
+  process.once("disconnect", () => controller.abort(new Error("Context generation was cancelled")));
+  try {
+    const plugins = request.includePlugins && request.depth !== undefined ? await contributors(request.folder) : [];
+    await send({ type: "stage", stage: "core context" });
+    const text = await buildLlmContext({
+      folder: request.folder,
+      depth: request.depth,
+      profile: request.profile,
+      includeInstructions: request.includeInstructions,
+      plugins,
+      signal: controller.signal
+    });
+    await send({ type: "result", ok: true, text });
+  } catch (error) {
+    await send({ type: "result", ok: false, error: error instanceof Error ? error.message : String(error) });
+  }
+  process.exit(0);
+}
+await main();