testeiya 0.2.1 → 0.3.10

package/src/context-store.ts

@@ -1,265 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import dedent from "dedent";
-import {
-  PROJECT_DIR,
-  CONTEXT_CODE_SUBDIR,
-  CONTEXT_REQUIREMENTS_SUBDIR,
-  MANUAL_TESTS_SUBDIR,
-  contextManifestPath,
-  ensureProjectDirGuards,
-} from "./project-dir.js";
-
-/**
- * Workspace context: extra resources attached to a workspace so the agent can
- * consult them — symlinked local folders and shallow-cloned git repos (both
- * directly under `.testeiya/<name>`, named after the source) and documents
- * (under `.testeiya/requirements/` and `.testeiya/docs/`). The manifest
- * (`.testeiya/context.json`) records what the user added via the UI;
- * `listContext` folds in anything else found in the legacy `.testeiya/code/`
- * dir (e.g. put there by the agent itself), so the system prompt and the chat
- * status bar always reflect the real folder contents.
- */
-
-/** Extra doc dir the agent writes on its own (see the system prompt's context structure). */
-const CONTEXT_DOCS_SUBDIR = "docs";
-
-/**
- * The predefined `.testeiya` context structure — mirrors the system prompt's
- * <context-workspace> section. Only these are surfaced as status-bar sections;
- * anything else inside `.testeiya` (uploads, skills, ad-hoc agent dirs) is
- * plumbing, not context. User-added entries (linked folders, cloned repos)
- * live directly under `.testeiya/<name>` and must never shadow these names.
- */
-export const CONTEXT_SECTION_DIRS = [
-  MANUAL_TESTS_SUBDIR,
-  CONTEXT_CODE_SUBDIR,
-  CONTEXT_REQUIREMENTS_SUBDIR,
-  CONTEXT_DOCS_SUBDIR,
-  "auto-tests",
-  "exploratory",
-];
-
-/** The non-empty predefined context folders, one status-bar section each. */
-export function listContextFolders(cwd: string): ContextFolder[] {
-  const folders: ContextFolder[] = [];
-  for (const name of CONTEXT_SECTION_DIRS) {
-    const count = readdirSafe(path.join(cwd, PROJECT_DIR, name)).filter(
-      (e) => !e.name.startsWith(".")
-    ).length;
-    if (count === 0) continue;
-    folders.push({ name, path: `${PROJECT_DIR}/${name}`, count });
-  }
-  return folders;
-}
-
-/** Every context entry: the manifest plus items discovered on disk. */
-export function listContext(cwd: string): ContextEntry[] {
-  const manifest = loadContextEntries(cwd);
-  const known = new Set(manifest.map((e) => e.path));
-  const discovered: ContextEntry[] = [];
-  discoverDirs(cwd, CONTEXT_CODE_SUBDIR, known, discovered);
-  discoverFiles(cwd, CONTEXT_REQUIREMENTS_SUBDIR, known, discovered);
-  discoverFiles(cwd, CONTEXT_DOCS_SUBDIR, known, discovered);
-  return [...manifest, ...discovered];
-}
-
-export function loadContextEntries(cwd: string): ContextEntry[] {
-  let raw: { entries?: ContextEntry[] };
-  try {
-    raw = JSON.parse(fs.readFileSync(contextManifestPath(cwd), "utf8"));
-  } catch {
-    return [];
-  }
-  const entries = Array.isArray(raw.entries) ? raw.entries : [];
-  return entries.filter((e) => e?.path && exists(path.join(cwd, e.path)));
-}
-
-export function saveContextEntries(cwd: string, entries: ContextEntry[]): void {
-  const dir = path.join(cwd, PROJECT_DIR);
-  fs.mkdirSync(dir, { recursive: true });
-  ensureProjectDirGuards(cwd);
-  fs.writeFileSync(
-    contextManifestPath(cwd),
-    JSON.stringify({ entries, updatedAt: new Date().toISOString() }, null, 2)
-  );
-}
-
-/**
- * Change marker for the workspace context: the manifest mtime plus the set of
- * non-empty predefined folders (so a mid-session pull that seeds
- * `manual-tests` also registers as a change). "" when nothing exists.
- */
-export function contextStamp(cwd: string): string {
-  let mtime = 0;
-  try {
-    mtime = fs.statSync(contextManifestPath(cwd)).mtimeMs;
-  } catch {
-    // no manifest yet
-  }
-  const names = listContextFolders(cwd).map((f) => f.name);
-  return `${mtime}|${names.join(",")}`;
-}
-
-/** System-prompt section describing the workspace context; "" when none. */
-export function contextPromptSection(
-  entries: ContextEntry[],
-  folders: ContextFolder[] = []
-): string {
-  if (entries.length === 0 && folders.length === 0) return "";
-  return dedent`
-  <workspace-context>
-    This workspace has context attached — the user (or you, earlier) put it there for a purpose. Consult it before answering, and prefer it over assumptions about the project.
-
-  ${contextLines(entries, folders)}
-
-    ALL of it lives under the hidden \`${PROJECT_DIR}/\` dir: file-search tools skip hidden dirs by default, so search it explicitly (pass hidden:true, or prefix the path with \`${PROJECT_DIR}/\`). Linked folders and cloned repositories are reference material: read them, never modify them. A linked folder is a symlink — wildcard searches do not descend into it; search it with its own path prefix (e.g. \`${PROJECT_DIR}/<name>/\`). Documents under \`${PROJECT_DIR}/requirements\` and \`${PROJECT_DIR}/docs\` are specs and plans — use them when writing or reviewing tests.
-  </workspace-context>
-  `;
-}
-
-/** Per-prompt notice when the context changed mid-session; appended to the next prompt. */
-export function contextUpdateNotice(
-  entries: ContextEntry[],
-  folders: ContextFolder[] = []
-): string {
-  if (entries.length === 0 && folders.length === 0) {
-    return dedent`
-    <workspace-context-update>
-      All extra workspace context was removed. Do not rely on it anymore.
-    </workspace-context-update>
-    `;
-  }
-  return dedent`
-  <workspace-context-update>
-    The workspace context just changed. It now contains:
-
-  ${contextLines(entries, folders)}
-
-    This was done for a purpose — take it into account for this and future requests. Remember \`${PROJECT_DIR}/\` is hidden: search it with hidden:true or an explicit path prefix.
-  </workspace-context-update>
-  `;
-}
-
-function contextLines(entries: ContextEntry[], folders: ContextFolder[]): string {
-  const lines: string[] = [];
-  const covered = new Set(entries.map((e) => parentDir(e.path)));
-  for (const f of folders) {
-    if (covered.has(f.path)) continue;
-    lines.push(`- \`${f.path}/\` — ${folderPurpose(f.name)}`);
-  }
-  for (const e of entries) lines.push(`- ${describeEntry(e)}`);
-  return lines.join("\n");
-}
-
-function folderPurpose(name: string): string {
-  if (name === "manual-tests") {
-    return "the project's manual test suites pulled from Testomat.io (*.test.md — THE manual tests of this project)";
-  }
-  if (name === "code") return "reference code added as context";
-  if (name === "requirements") return "requirements and specs";
-  if (name === "docs") return "test planning and strategy documents";
-  if (name === "auto-tests") return "automated test references";
-  return "exploratory testing setup";
-}
-
-function parentDir(rel: string): string {
-  const idx = rel.lastIndexOf("/");
-  if (idx < 0) return "";
-  return rel.slice(0, idx);
-}
-
-function describeEntry(e: ContextEntry): string {
-  const date = e.addedAt?.split("T")[0] ?? "";
-  let from = "";
-  if (e.origin && e.origin !== e.name) from = ` from ${e.origin}`;
-  if (e.kind === "repo") return `\`${e.path}\` — git repository${from} (${date})`;
-  if (e.kind === "folder") return `\`${e.path}\` — local folder${from} (${date})`;
-  return `\`${e.path}\` — document${from} (${date})`;
-}
-
-// Top-level dirs in `.testeiya/code` not in the manifest: `folder` entries, or
-// `repo` when they carry their own `.git` (a clone made by the agent).
-function discoverDirs(
-  cwd: string,
-  subdir: string,
-  known: Set<string>,
-  out: ContextEntry[]
-): void {
-  for (const entry of readdirSafe(path.join(cwd, PROJECT_DIR, subdir))) {
-    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-    const rel = `${PROJECT_DIR}/${subdir}/${entry.name}`;
-    if (known.has(rel)) continue;
-    let kind: ContextKind = "folder";
-    if (!entry.isSymbolicLink() && fs.existsSync(path.join(cwd, rel, ".git"))) kind = "repo";
-    out.push(discoveredEntry(cwd, kind, entry.name, rel));
-  }
-}
-
-function discoverFiles(
-  cwd: string,
-  subdir: string,
-  known: Set<string>,
-  out: ContextEntry[]
-): void {
-  for (const entry of readdirSafe(path.join(cwd, PROJECT_DIR, subdir))) {
-    if (!entry.isFile() || entry.name.startsWith(".")) continue;
-    const rel = `${PROJECT_DIR}/${subdir}/${entry.name}`;
-    if (known.has(rel)) continue;
-    out.push(discoveredEntry(cwd, "file", entry.name, rel));
-  }
-}
-
-function discoveredEntry(
-  cwd: string,
-  kind: ContextKind,
-  name: string,
-  rel: string
-): ContextEntry {
-  let addedAt = "";
-  try {
-    addedAt = fs.lstatSync(path.join(cwd, rel)).mtime.toISOString();
-  } catch {
-    // keep empty — the entry is still listable
-  }
-  return { id: `fs:${rel}`, kind, name, path: rel, origin: "", addedAt };
-}
-
-function readdirSafe(dir: string): fs.Dirent[] {
-  try {
-    return fs.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-}
-
-function exists(p: string): boolean {
-  try {
-    fs.lstatSync(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export type ContextKind = "folder" | "repo" | "file";
-
-/** A top-level `.testeiya` folder shown as a status-bar section. */
-export interface ContextFolder {
-  name: string;
-  /** Relative to cwd (`.testeiya/<name>`). */
-  path: string;
-  /** Direct children (files + dirs, dot entries excluded). */
-  count: number;
-}
-
-export interface ContextEntry {
-  id: string;
-  kind: ContextKind;
-  name: string;
-  /** Location inside the workspace, relative to cwd (always under `.testeiya/`). */
-  path: string;
-  /** Where it came from: an absolute local path, a git URL, or the uploaded filename. */
-  origin: string;
-  addedAt: string;
-}

package/src/debug-bus.ts

@@ -1,405 +0,0 @@
-import { appendFileSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { log, type WideEvent } from "evlog";
-import { readMemoryLogs } from "evlog/memory";
-
-/*
- * Server-side instrumentation for the sidebar Debug panel, built on the evlog
- * pipeline that `file-log.ts` initializes. The real outbound calls to the
- * Testomat.io API server happen here in the Bun process (the v2 proxy,
- * attachment upload, transcription) — the browser only ever sees the
- * same-origin `/api/testomatio/*` proxy hop. `loggedServerFetch` (and
- * `publish` for the `ai` / `check-tests` channels) emits one evlog wide event
- * per call; the shared drain fans it out to the NDJSON app log, the in-memory
- * ring buffer (`evlog/memory` — the snapshot's source), and `panelDrain`
- * below, which maps panel-facing channels onto the `DebugEntry` wire shapes
- * the `/api/debug/stream` SSE feed and the client panel already speak.
- *
- * While debug mode is on — the panel is open (an SSE subscriber is connected)
- * or `TESTEIYA_DEBUG=1` is set — each request + response is also appended to
- * `cli/log/testomatio.http` (gitignored) as a re-runnable `.http` block
- * (VS Code REST Client / JetBrains), with the response captured as trailing
- * comments so the agent can verify the REST API. The file includes the
- * `Authorization` header so requests actually replay; that token never reaches
- * the panel or the SSE feed.
- */
-
-const MAX_BODY = 16000;
-const FILE_RESPONSE_MAX = 6000;
-const LOG_DIR = fileURLToPath(new URL("../log", import.meta.url));
-const REPLAY_FILE = join(LOG_DIR, "testomatio.http");
-
-let panelSeq = 0;
-let dirReady = false;
-let latestReportKey: string | null = null;
-const clientReports = new Map<string, ClientReport>();
-const subscribers = new Set<(entry: DebugEntry) => void>();
-
-export async function loggedServerFetch(
-  url: string,
-  init: RequestInit,
-  requestBody?: string | null
-): Promise<{ res: Response; text: string }> {
-  const method = (init.method ?? "GET").toUpperCase();
-  const started = Date.now();
-  try {
-    const res = await fetch(url, init);
-    const text = await res.text();
-    record(
-      {
-        method,
-        url,
-        requestBody: requestBody ?? null,
-        status: res.status,
-        ok: res.ok,
-        responseBody: text,
-        error: null,
-        durationMs: Date.now() - started,
-      },
-      init.headers
-    );
-    return { res, text };
-  } catch (e) {
-    if ((e as { name?: string })?.name === "AbortError") throw e;
-    record(
-      {
-        method,
-        url,
-        requestBody: requestBody ?? null,
-        status: null,
-        ok: false,
-        responseBody: null,
-        error: e instanceof Error ? e.message : String(e),
-        durationMs: Date.now() - started,
-      },
-      init.headers
-    );
-    throw e;
-  }
-}
-
-/**
- * Record a `check-tests` subprocess run (pull/push) as a Debug-panel event so its
- * outcome + full output are visible alongside requests — the same feed the panel
- * already renders, so an exit-1 sync stops being a silent "[check-tests] exited 1".
- */
-export function publishCheckTests(run: {
-  action: string;
-  dir: string;
-  code: number | null;
-  output: string;
-  durationMs: number;
-}): void {
-  publish({
-    kind: "event",
-    channel: "check-tests",
-    name: `check-tests ${run.action}`,
-    summary: `${run.code === 0 ? "ok" : `exit ${run.code}`} · ${run.dir} · ${run.durationMs}ms`,
-    ok: run.code === 0,
-    detail: truncate(run.output),
-  });
-}
-
-export function subscribeDebug(cb: (entry: DebugEntry) => void): () => void {
-  subscribers.add(cb);
-  return () => {
-    subscribers.delete(cb);
-  };
-}
-
-export function recentDebugEntries(): DebugEntry[] {
-  return readMemoryLogs()
-    .map(toPanelEntry)
-    .filter((entry): entry is DebugEntry => !!entry);
-}
-
-/*
- * Latest client debug report per session — the browser's unified activity log
- * (`api` + `agent` + `console` channels) plus a MobX store snapshot, pushed via
- * `POST /api/debug/report`. Keyed by session so a snapshot request can pick the
- * matching one; `latestReportKey` is the fallback when no session is given.
- */
-export function recordClientReport(report: ClientReport): void {
-  const key = report.sessionId || "default";
-  clientReports.set(key, report);
-  latestReportKey = key;
-}
-
-export function buildSnapshot(sessionId?: string | null): DebugSnapshot {
-  const events = readMemoryLogs();
-  const entries = events.map(toPanelEntry);
-  return {
-    generatedAt: new Date().toISOString(),
-    server: {
-      requests: entries.filter((e): e is ServerRequestEntry => !!e && e.kind === "request"),
-      ai: entries.filter((e): e is AiEventEntry => !!e && e.kind === "ai"),
-      checkTests: entries.filter((e): e is ProcessEventEntry => !!e && e.kind === "event"),
-      console: events.filter((e) => e.tag === "console").map(toConsoleEntry),
-      api: events.filter((e) => e.channel === "api"),
-      prompts: events.filter((e) => e.channel === "prompt"),
-    },
-    client: getClientReport(sessionId),
-    langfuseHint: "bun run debug:trace session:<agent-conversation-id>",
-  };
-}
-
-export function clientLayout(
-  sessionId?: string | null
-): { layout: unknown; reportedAt: string | null; url: string | null } | null {
-  const report = getClientReport(sessionId);
-  if (!report) return null;
-  let url: string | null = null;
-  const meta = report.meta as { url?: unknown } | null;
-  if (meta && typeof meta.url === "string") url = meta.url;
-  return { layout: report.layout ?? null, reportedAt: report.reportedAt, url };
-}
-
-/*
- * Generic sink for any non-request debug entry (currently the `ai` channel —
- * pi-coding-agent LLM interactions; see `ai-debug.ts`). Emits an evlog wide
- * event, which the shared drain routes to the file/memory sinks and back into
- * `panelDrain` for the live SSE feed.
- */
-export function publish(entry: WithoutMeta<DebugEntry>): void {
-  const { kind: _, ...fields } = entry;
-  if (entry.ok) {
-    log.info(fields);
-    return;
-  }
-  log.error(fields);
-}
-
-/**
- * Drain hook wired into the evlog pipeline by `file-log.ts`: maps panel-facing
- * wide events onto the `DebugEntry` wire shapes and pushes them to the live
- * SSE subscribers. Non-panel channels (`api`, `prompt`, `console`) stay in the
- * file/memory sinks only.
- */
-export function panelDrain(event: WideEvent): void {
-  const entry = toPanelEntry(event);
-  if (!entry) return;
-  for (const cb of subscribers) cb(entry);
-}
-
-function getClientReport(sessionId?: string | null): ClientReport | null {
-  if (sessionId && clientReports.has(sessionId)) return clientReports.get(sessionId)!;
-  if (latestReportKey) return clientReports.get(latestReportKey) ?? null;
-  return null;
-}
-
-function toPanelEntry(event: WideEvent): DebugEntry | null {
-  const e = event as Record<string, any>;
-  const channel = e.channel;
-  if (channel !== "testomatio" && channel !== "ai" && channel !== "check-tests") return null;
-  if (!e._panelId) {
-    panelSeq += 1;
-    e._panelId = panelSeq;
-  }
-  const id = e._panelId as number;
-  const ts = Date.parse(e.timestamp) || Date.now();
-  if (channel === "testomatio") {
-    return {
-      kind: "request",
-      channel: "testomatio",
-      id,
-      ts,
-      method: e.method,
-      url: e.url,
-      requestBody: e.requestBody ?? null,
-      status: e.status ?? null,
-      ok: !!e.ok,
-      responseBody: e.responseBody ?? null,
-      error: e.error ?? null,
-      durationMs: e.durationMs ?? 0,
-    };
-  }
-  if (channel === "ai") {
-    return {
-      kind: "ai",
-      channel: "ai",
-      id,
-      ts,
-      name: e.name,
-      summary: e.summary ?? null,
-      ok: !!e.ok,
-      model: e.model ?? null,
-      durationMs: e.durationMs ?? null,
-      tokens: e.tokens ?? null,
-      detail: e.detail ?? null,
-    };
-  }
-  return {
-    kind: "event",
-    channel: "check-tests",
-    id,
-    ts,
-    name: e.name,
-    summary: e.summary ?? null,
-    ok: !!e.ok,
-    detail: e.detail ?? null,
-  };
-}
-
-function toConsoleEntry(event: WideEvent): ServerConsoleEntry {
-  let level: ServerConsoleEntry["level"] = "log";
-  if (event.level === "warn") level = "warn";
-  if (event.level === "error") level = "error";
-  return {
-    level,
-    ts: Date.parse(event.timestamp) || 0,
-    text: String((event as Record<string, unknown>).message ?? ""),
-  };
-}
-
-function record(partial: RequestData, headers?: HeadersInit): void {
-  const outcome = partial.error ?? partial.status ?? "—";
-  console.log(
-    `[testomatio→] ${partial.method} ${partial.url} → ${outcome} (${partial.durationMs}ms)`
-  );
-  const event = {
-    channel: "testomatio",
-    ...partial,
-    requestBody: truncate(partial.requestBody),
-    responseBody: truncate(partial.responseBody),
-  };
-  if (partial.ok) log.info(event);
-  else log.error(event);
-  writeReplayFile(partial, headers);
-}
-
-function writeReplayFile(data: RequestData, headers?: HeadersInit): void {
-  if (subscribers.size === 0 && process.env.TESTEIYA_DEBUG !== "1") return;
-  try {
-    if (!dirReady) {
-      mkdirSync(LOG_DIR, { recursive: true });
-      dirReady = true;
-    }
-    appendFileSync(REPLAY_FILE, formatHttp(data, headers));
-  } catch {}
-}
-
-function formatHttp(data: RequestData, headers?: HeadersInit): string {
-  const ts = new Date().toISOString();
-  const resource = data.url.replace(/\?.*$/, "").split("/").pop() || data.url;
-  const outcome = data.error ? `ERR ${data.error}` : data.status;
-  const lines = [
-    `### ${data.method} ${resource} — ${ts} → ${outcome} (${data.durationMs}ms)`,
-    `${data.method} ${data.url}`,
-  ];
-  for (const [key, value] of headerEntries(headers)) lines.push(`${key}: ${value}`);
-  if (data.requestBody && data.requestBody.startsWith("[multipart]")) {
-    lines.push(`# ${data.requestBody} (binary body not captured)`);
-  }
-  if (data.requestBody && !data.requestBody.startsWith("[multipart]")) {
-    lines.push("", data.requestBody);
-  }
-  lines.push("", ...responseComment(data), "", "");
-  return lines.join("\n");
-}
-
-function responseComment(data: RequestData): string[] {
-  if (data.error) return [`# ── error: ${data.error} ──`];
-  const head = `# ── response ${data.status} (${data.durationMs}ms) ──`;
-  if (!data.responseBody) return [head];
-  let body = data.responseBody;
-  if (body.length > FILE_RESPONSE_MAX) {
-    body = `${body.slice(0, FILE_RESPONSE_MAX)}… (truncated)`;
-  }
-  return [head, ...body.split("\n").map((line) => `# ${line}`)];
-}
-
-function headerEntries(headers?: HeadersInit): [string, string][] {
-  if (!headers) return [];
-  if (headers instanceof Headers) return [...headers.entries()];
-  if (Array.isArray(headers)) return headers as [string, string][];
-  return Object.entries(headers);
-}
-
-function truncate(value: string | null): string | null {
-  if (!value) return value;
-  if (value.length <= MAX_BODY) return value;
-  return `${value.slice(0, MAX_BODY)}… (+${value.length - MAX_BODY} more chars)`;
-}
-
-type RequestData = Omit<ServerRequestEntry, "id" | "ts" | "kind" | "channel">;
-
-// Distributes over the union so each member keeps its own keys (a plain
-// `Omit<A | B, K>` collapses to only the keys common to A and B).
-type WithoutMeta<T> = T extends unknown ? Omit<T, "id" | "ts"> : never;
-
-export interface ServerRequestEntry {
-  kind: "request";
-  channel: "testomatio";
-  id: number;
-  ts: number;
-  method: string;
-  url: string;
-  requestBody: string | null;
-  status: number | null;
-  ok: boolean;
-  responseBody: string | null;
-  error: string | null;
-  durationMs: number;
-}
-
-// Mirrors `AiLogEntry` in `lib/debug/external-log.ts` so entries ride the SSE
-// feed straight into the panel's `record()`.
-export interface AiEventEntry {
-  kind: "ai";
-  channel: "ai";
-  id: number;
-  ts: number;
-  name: string;
-  summary: string | null;
-  ok: boolean;
-  model: string | null;
-  durationMs: number | null;
-  tokens: { input: number; output: number; total: number } | null;
-  detail: string | null;
-}
-
-// A `check-tests` subprocess run, shaped to match the client's `EventLogEntry`
-// so it rides the SSE feed straight into the panel's event rows.
-export interface ProcessEventEntry {
-  kind: "event";
-  channel: "check-tests";
-  id: number;
-  ts: number;
-  name: string;
-  summary: string | null;
-  ok: boolean;
-  detail: string | null;
-}
-
-export type DebugEntry = ServerRequestEntry | AiEventEntry | ProcessEventEntry;
-
-export interface ServerConsoleEntry {
-  level: "log" | "warn" | "error";
-  ts: number;
-  text: string;
-}
-
-export interface ClientReport {
-  sessionId: string | null;
-  reason: string;
-  reportedAt: string;
-  entries: unknown[];
-  store: unknown;
-  meta: unknown;
-  layout?: unknown;
-}
-
-export interface DebugSnapshot {
-  generatedAt: string;
-  server: {
-    requests: ServerRequestEntry[];
-    ai: AiEventEntry[];
-    checkTests: ProcessEventEntry[];
-    console: ServerConsoleEntry[];
-    api: WideEvent[];
-    prompts: WideEvent[];
-  };
-  client: ClientReport | null;
-  langfuseHint: string;
-}