@bjoernrochel/sevro 0.1.0-rc.2 → 0.1.0-rc.21

package/src/generated-fixture.ts

@@ -1,220 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { canonicalJson } from "./identity";
-import { prepareFixtureBin } from "./fixture-bin";
-import { prepareGitHooks } from "./git-hooks";
-import { fixtureParts } from "./preparation";
-
-const MAX_COMMITS = 128;
-const MAX_FILES = 1024;
-const MAX_BYTES = 32 * 1024 * 1024;
-const MAX_GIT_OUTPUT = 64 * 1024;
-
-export interface GeneratedFixture {
-  kind: "generated";
-  commits: { message: string; files: Record<string, string> }[];
-  files?: Record<string, string>;
-  staged?: string[];
-  commitFiles?: boolean;
-  hooks?: Record<string, string>;
-  bin?: Record<string, string>;
-}
-
-function validFiles(value: unknown): value is Record<string, string> {
-  return (
-    Boolean(value && typeof value === "object" && !Array.isArray(value)) &&
-    Object.values(value as object).every((item) => typeof item === "string")
-  );
-}
-
-function validPath(path: string): void {
-  const parts = fixtureParts(path);
-  if (parts.some((part) => part.toLowerCase() === ".git"))
-    throw new Error("generated fixture cannot write repository metadata");
-}
-
-/** Freeze a bounded declarative history before any host or fixture work. */
-export function prepareGeneratedFixture(value: unknown): GeneratedFixture {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    throw new Error("invalid generated fixture");
-  const fixture = value as Record<string, unknown>;
-  if (
-    fixture.kind !== "generated" ||
-    Object.keys(fixture).some(
-      (key) =>
-        ![
-          "kind",
-          "commits",
-          "files",
-          "staged",
-          "commitFiles",
-          "hooks",
-          "bin",
-        ].includes(key),
-    ) ||
-    !Array.isArray(fixture.commits) ||
-    fixture.commits.length > MAX_COMMITS ||
-    (fixture.files !== undefined && !validFiles(fixture.files)) ||
-    (fixture.staged !== undefined &&
-      (!Array.isArray(fixture.staged) ||
-        !fixture.staged.every((item: unknown) => typeof item === "string"))) ||
-    (fixture.commitFiles !== undefined &&
-      typeof fixture.commitFiles !== "boolean")
-  )
-    throw new Error("invalid generated fixture");
-  prepareGitHooks(fixture.hooks);
-  prepareFixtureBin(fixture.bin);
-  let bytes = 0;
-  let files = 0;
-  const paths: string[] = [];
-  for (const commit of fixture.commits) {
-    if (
-      !commit ||
-      typeof commit !== "object" ||
-      Array.isArray(commit) ||
-      Object.keys(commit).some((key) => key !== "message" && key !== "files") ||
-      typeof commit.message !== "string" ||
-      !commit.message.trim() ||
-      Buffer.byteLength(commit.message, "utf8") > 4096 ||
-      !validFiles(commit.files) ||
-      Object.keys(commit.files).length === 0
-    )
-      throw new Error("invalid generated fixture commit");
-    bytes += Buffer.byteLength(commit.message, "utf8");
-    for (const [path, content] of Object.entries(
-      commit.files as Record<string, string>,
-    )) {
-      validPath(path);
-      paths.push(path);
-      files++;
-      bytes +=
-        Buffer.byteLength(path, "utf8") + Buffer.byteLength(content, "utf8");
-    }
-  }
-  const overlay = (fixture.files ?? {}) as Record<string, string>;
-  for (const [path, content] of Object.entries(overlay)) {
-    validPath(path);
-    paths.push(path);
-    files++;
-    bytes +=
-      Buffer.byteLength(path, "utf8") + Buffer.byteLength(content, "utf8");
-  }
-  bytes += ((fixture.staged ?? []) as string[]).reduce(
-    (size, path) => size + Buffer.byteLength(path, "utf8"),
-    0,
-  );
-  if (files > MAX_FILES || bytes > MAX_BYTES)
-    throw new Error("generated fixture exceeds the size limit");
-  const unique = [...new Set(paths)];
-  const normalized = unique.map((path) => path.toLowerCase());
-  for (let index = 0; index < normalized.length; index++) {
-    for (let other = 0; other < index; other++) {
-      if (
-        normalized[index] === normalized[other] ||
-        normalized[index]!.startsWith(`${normalized[other]}/`) ||
-        normalized[other]!.startsWith(`${normalized[index]}/`)
-      )
-        throw new Error("generated fixture paths collide");
-    }
-  }
-  const staged = (fixture.staged ?? []) as string[];
-  if (
-    new Set(staged.map((path) => path.toLowerCase())).size !== staged.length ||
-    staged.some((path) => !Object.hasOwn(overlay, path)) ||
-    (fixture.commitFiles === true && Object.keys(overlay).length === 0)
-  )
-    throw new Error("invalid generated fixture staging");
-  return JSON.parse(canonicalJson(fixture)) as GeneratedFixture;
-}
-
-async function git(workspace: string, args: string[]): Promise<void> {
-  async function bounded(stream: ReadableStream<Uint8Array>): Promise<void> {
-    let size = 0;
-    for await (const chunk of stream) {
-      size += chunk.byteLength;
-      if (size > MAX_GIT_OUTPUT)
-        throw new Error("generated fixture Git output is too large");
-    }
-  }
-  const proc = Bun.spawn(
-    [
-      "git",
-      "-c",
-      `core.hooksPath=${process.platform === "win32" ? "NUL" : "/dev/null"}`,
-      ...args,
-    ],
-    {
-      cwd: workspace,
-      stdout: "pipe",
-      stderr: "pipe",
-      env: {
-        PATH: process.env.PATH ?? "/usr/bin:/bin",
-        ...(process.env.SystemRoot
-          ? { SystemRoot: process.env.SystemRoot }
-          : {}),
-        GIT_CONFIG_NOSYSTEM: "1",
-        GIT_CONFIG_GLOBAL: process.platform === "win32" ? "NUL" : "/dev/null",
-        GIT_TERMINAL_PROMPT: "0",
-        GIT_AUTHOR_NAME: "Sevro Fixture",
-        GIT_AUTHOR_EMAIL: "fixture@sevro.invalid",
-        GIT_COMMITTER_NAME: "Sevro Fixture",
-        GIT_COMMITTER_EMAIL: "fixture@sevro.invalid",
-        GIT_AUTHOR_DATE: "2000-01-01T00:00:00+00:00",
-        GIT_COMMITTER_DATE: "2000-01-01T00:00:00+00:00",
-      },
-    },
-  );
-  try {
-    const [, , code] = await Promise.all([
-      bounded(proc.stdout),
-      bounded(proc.stderr),
-      proc.exited,
-    ]);
-    if (code !== 0) throw new Error();
-  } catch {
-    try {
-      proc.kill("SIGKILL");
-    } catch {
-      // The process may have exited before the failure was observed.
-    }
-    await proc.exited;
-    throw new Error("generated fixture Git operation failed");
-  }
-}
-
-async function writeFiles(
-  workspace: string,
-  files: Record<string, string>,
-): Promise<void> {
-  for (const [path, content] of Object.entries(files)) {
-    const target = join(workspace, ...fixtureParts(path));
-    await mkdir(dirname(target), { recursive: true, mode: 0o700 });
-    await writeFile(target, content, { flag: "w", mode: 0o600 });
-  }
-}
-
-/** Build a deterministic local Git history, then apply working-tree state. */
-export async function materializeGeneratedFixture(
-  fixture: GeneratedFixture,
-  workspace: string,
-): Promise<void> {
-  await git(workspace, ["init", "--quiet", "--initial-branch=main"]);
-  for (const commit of fixture.commits) {
-    await writeFiles(workspace, commit.files);
-    await git(workspace, ["add", "--", ...Object.keys(commit.files)]);
-    await git(workspace, ["commit", "--quiet", "-m", commit.message]);
-  }
-  const overlay = fixture.files ?? {};
-  await writeFiles(workspace, overlay);
-  if (fixture.commitFiles) {
-    await git(workspace, ["add", "--", ...Object.keys(overlay)]);
-    await git(workspace, [
-      "commit",
-      "--quiet",
-      "-m",
-      "Add evaluation scaffolding",
-    ]);
-  }
-  if (fixture.staged?.length)
-    await git(workspace, ["add", "--", ...fixture.staged]);
-}

package/src/git-hooks.ts

@@ -1,63 +0,0 @@
-import { chmod, lstat, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-const MAX_HOOKS = 32;
-const MAX_HOOK_BYTES = 1024 * 1024;
-
-/** Bound hook declarations and keep every name inside Git's hooks directory. */
-export function prepareGitHooks(value: unknown): Record<string, string> | null {
-  if (value === undefined) return null;
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    throw new Error("invalid fixture hooks");
-  const hooks = value as Record<string, unknown>;
-  const entries = Object.entries(hooks);
-  if (
-    entries.length > MAX_HOOKS ||
-    entries.some(
-      ([name, content]) =>
-        !/^[a-z][a-z0-9-]*$/.test(name) ||
-        name.length > 64 ||
-        typeof content !== "string" ||
-        !content ||
-        content.includes("\0"),
-    ) ||
-    entries.reduce(
-      (size, [name, content]) =>
-        size +
-        Buffer.byteLength(name, "utf8") +
-        Buffer.byteLength(content as string, "utf8"),
-      0,
-    ) > MAX_HOOK_BYTES
-  )
-    throw new Error("invalid fixture hooks");
-  return hooks as Record<string, string>;
-}
-
-/** Install executable hooks only after fixture commits and overlays are ready. */
-export async function installGitHooks(
-  hooks: Record<string, string> | undefined,
-  workspace: string,
-): Promise<void> {
-  if (!hooks) return;
-  const directory = join(workspace, ".git", "hooks");
-  const root = await lstat(directory);
-  if (!root.isDirectory() || root.isSymbolicLink())
-    throw new Error("fixture Git hooks directory is invalid");
-  for (const [name, content] of Object.entries(hooks)) {
-    const target = join(directory, name);
-    try {
-      const existing = await lstat(target);
-      if (!existing.isFile() || existing.isSymbolicLink())
-        throw new Error("fixture Git hook target is invalid");
-    } catch (error) {
-      if (!(
-        error instanceof Error &&
-        "code" in error &&
-        error.code === "ENOENT"
-      ))
-        throw error;
-    }
-    await writeFile(target, content, { mode: 0o755 });
-    await chmod(target, 0o755);
-  }
-}

package/src/hosts/claude-nested-skills.ts

@@ -1,218 +0,0 @@
-import { lstat, readFile, readdir, realpath } from "node:fs/promises";
-import { join } from "node:path";
-
-type Entry = Record<string, unknown>;
-const MAX_BYTES = 8 * 1024 * 1024;
-const MAX_AGENTS = 64;
-const MAX_SKILLS = 128;
-
-function record(value: unknown): value is Entry {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-function label(value: unknown): value is string {
-  return typeof value === "string" && /^[A-Za-z0-9_.:-]{1,256}$/.test(value);
-}
-
-function identity(value: unknown): value is string {
-  return typeof value === "string" && /^[A-Za-z0-9_-]{1,128}$/.test(value);
-}
-
-function blocks(entry: Entry): Entry[] {
-  const content = record(entry.message) ? entry.message.content : null;
-  return Array.isArray(content) ? content.filter(record) : [];
-}
-
-function entries(text: string): Entry[] {
-  return text
-    .split(/\r?\n/)
-    .filter(Boolean)
-    .map((line) => {
-      const parsed: unknown = JSON.parse(line);
-      if (!record(parsed)) throw new Error("invalid Claude session entry");
-      return parsed;
-    });
-}
-
-async function readSession(path: string): Promise<string> {
-  const file = await lstat(path);
-  if (!file.isFile() || file.isSymbolicLink() || file.size > MAX_BYTES)
-    throw new Error("Claude session file is unavailable");
-  return readFile(path, "utf8");
-}
-
-type NestedSkill = {
-  ancestorToolUseId: string;
-  skill: string;
-  invocation: string;
-};
-
-type State = {
-  sessionId: string;
-  projectDir: string;
-  seen: Set<string>;
-  calls: NestedSkill[];
-};
-
-async function sidecarChild(
-  state: State,
-  toolUseId: string,
-  parentAgentId: string | null,
-): Promise<string> {
-  const directory = join(state.projectDir, state.sessionId, "subagents");
-  const names = (await readdir(directory)).filter((name) =>
-    /^agent-[A-Za-z0-9_-]+\.meta\.json$/.test(name),
-  );
-  if (names.length > MAX_AGENTS) throw new Error("excessive Claude agents");
-  const matches: string[] = [];
-  for (const name of names) {
-    const metadata: unknown = JSON.parse(
-      await readSession(join(directory, name)),
-    );
-    if (
-      record(metadata) &&
-      metadata.toolUseId === toolUseId &&
-      (metadata.parentAgentId ?? null) === parentAgentId
-    )
-      matches.push(name.slice(6, -10));
-  }
-  if (matches.length !== 1 || !identity(matches[0]))
-    throw new Error("Claude child identity is unavailable");
-  return matches[0]!;
-}
-
-async function childId(
-  entry: Entry,
-  state: State,
-  toolUseId: string,
-  parentAgentId: string | null,
-): Promise<string> {
-  const result = record(entry.toolUseResult) ? entry.toolUseResult : null;
-  if (result) {
-    if (result.status !== "completed" || !identity(result.agentId))
-      throw new Error("Claude child did not complete");
-    return result.agentId;
-  }
-  return sidecarChild(state, toolUseId, parentAgentId);
-}
-
-async function childSession(state: State, agentId: string) {
-  const directory = join(state.projectDir, state.sessionId, "subagents");
-  const path = join(directory, `agent-${agentId}.jsonl`);
-  if ((await realpath(path)) !== path)
-    throw new Error("Claude child session is redirected");
-  return readSession(path);
-}
-
-function skillCall(block: Entry, ancestorToolUseId: string | null) {
-  const invocation = record(block.input) ? block.input.skill : null;
-  if (!label(invocation)) throw new Error("invalid Claude Skill call");
-  return ancestorToolUseId
-    ? {
-        ancestorToolUseId,
-        skill: invocation.split(":").at(-1)!,
-        invocation,
-      }
-    : null;
-}
-
-async function visit(
-  text: string,
-  state: State,
-  agentId: string | null,
-  ancestorToolUseId: string | null,
-): Promise<void> {
-  const pending = new Set<string>();
-  for (const entry of entries(text)) {
-    if (entry.type !== "assistant" && entry.type !== "user") continue;
-    if (
-      entry.sessionId !== state.sessionId ||
-      (entry.agentId ?? null) !== agentId
-    )
-      throw new Error("Claude session identity mismatch");
-    for (const block of blocks(entry)) {
-      if (entry.type === "assistant" && block.type === "tool_use") {
-        if (block.name === "Skill") {
-          const call = skillCall(block, ancestorToolUseId);
-          if (call) state.calls.push(call);
-          if (state.calls.length > MAX_SKILLS)
-            throw new Error("excessive Claude Skill calls");
-        }
-        if (block.name === "Agent" || block.name === "Task") {
-          if (!identity(block.id) || pending.has(block.id))
-            throw new Error("invalid Claude Agent call");
-          pending.add(block.id);
-        }
-      }
-      if (
-        entry.type === "user" &&
-        block.type === "tool_result" &&
-        identity(block.tool_use_id) &&
-        pending.has(block.tool_use_id)
-      ) {
-        if (block.is_error === true)
-          throw new Error("Claude child call failed");
-        const child = await childId(entry, state, block.tool_use_id, agentId);
-        if (state.seen.has(child) || state.seen.size >= MAX_AGENTS)
-          throw new Error("repeated Claude child");
-        state.seen.add(child);
-        await visit(
-          await childSession(state, child),
-          state,
-          child,
-          ancestorToolUseId ?? block.tool_use_id,
-        );
-        pending.delete(block.tool_use_id);
-      }
-    }
-  }
-  if (pending.size) throw new Error("incomplete Claude Agent graph");
-}
-
-export async function claudeNestedSkillsObservation(
-  stream: string,
-  configRoot: string,
-  workspace: string,
-) {
-  const unavailable = {
-    id: "sevro.claude.nested-skills" as const,
-    completeness: "partial" as const,
-    data: { method: "native_session_graph", calls: [] as NestedSkill[] },
-  };
-  try {
-    const sessions = [
-      ...new Set(
-        entries(stream)
-          .filter((entry) => entry.type === "result")
-          .map((entry) => entry.session_id),
-      ),
-    ];
-    if (sessions.length !== 1 || !identity(sessions[0])) return unavailable;
-    const canonicalWorkspace = await realpath(workspace);
-    const canonicalConfigRoot = await realpath(configRoot);
-    const projectDir = join(
-      canonicalConfigRoot,
-      "projects",
-      canonicalWorkspace.replace(/[^A-Za-z0-9]/g, "-"),
-    );
-    const state: State = {
-      sessionId: sessions[0],
-      projectDir,
-      seen: new Set(),
-      calls: [],
-    };
-    await visit(
-      await readSession(join(projectDir, `${state.sessionId}.jsonl`)),
-      state,
-      null,
-      null,
-    );
-    return {
-      id: "sevro.claude.nested-skills" as const,
-      completeness: "complete" as const,
-      data: { method: "native_session_graph", calls: state.calls },
-    };
-  } catch {
-    return unavailable;
-  }
-}