@rmrdeveloper/sideroom-pi 8.10.0 → 8.12.0

package/extensions/jev/context.ts

@@ -0,0 +1,360 @@
+import { readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { extname, join, posix, relative, sep } from 'node:path';
+import ignore from 'ignore';
+import { LANGUAGE, languageForPath } from '../rules/catalog.ts';
+import {
+  buildFileState,
+  isTestPath,
+  type JevFileState,
+  type JevRelatedFile,
+  stateFitsBudget,
+} from './model.ts';
+
+const MAX_RELATED_FILES = 4;
+const MAX_SCAN_FILES = 1_024;
+const MAX_SCAN_DEPTH = 10;
+const MAX_CANDIDATE_BYTES = 32_000;
+const IGNORE_FILES = ['.gitignore', '.ignore', '.fdignore'] as const;
+const SENSITIVE_NAME =
+  /secret|credential|password|token|private.?key|api.?key|auth.?key|(?:^|[._-])(?:env|private|key)(?:[._-]|$)/iu;
+const SKIP_DIRECTORIES = new Set(['node_modules', 'dist', 'build', 'coverage']);
+
+interface Candidate {
+  readonly path: string;
+  readonly body: string;
+}
+
+interface ScanResult {
+  readonly candidates: readonly Candidate[];
+  readonly partial: boolean;
+}
+
+// Keep the edited file complete. Other files are included whole or not at all.
+export function buildContextualState(
+  cwd: string,
+  path: string,
+  body: string,
+  kind: string,
+  lines: Parameters<typeof buildFileState>[3],
+): JevFileState | undefined {
+  const base = buildFileState(path, body, kind, lines);
+  if (!stateFitsBudget(base)) {
+    return undefined;
+  }
+
+  const scan = scanSourceFiles(cwd, path);
+  const imported = references(path, body);
+  const related: JevRelatedFile[] = [];
+  let partial = scan.partial;
+  const matches = scan.candidates
+    .flatMap((candidate) => {
+      const importedByTarget = matchesReference(imported, candidate.path);
+      const consumesTarget = matchesReference(
+        references(candidate.path, candidate.body),
+        path,
+      );
+      const companionTest = isCompanionTest(path, candidate.path);
+      const testedSource = isCompanionTest(candidate.path, path);
+      if (
+        !importedByTarget &&
+        !consumesTarget &&
+        !companionTest &&
+        !testedSource
+      ) {
+        return [];
+      }
+      return [
+        {
+          ...candidate,
+          relation: isTestPath(candidate.path)
+            ? 'test'
+            : importedByTarget || testedSource
+              ? 'imported'
+              : 'consumer',
+        } as const,
+      ];
+    })
+    .sort((left, right) => {
+      if (left.relation !== right.relation) {
+        const priority = { test: 0, consumer: 1, imported: 2 };
+        return priority[left.relation] - priority[right.relation];
+      }
+      return compareText(left.path, right.path);
+    });
+
+  for (const candidate of matches) {
+    if (related.length >= MAX_RELATED_FILES) {
+      partial = true;
+      break;
+    }
+    const next = [...related, candidate];
+    if (!stateFitsBudget(buildFileState(path, body, kind, lines, next))) {
+      partial = true;
+      continue;
+    }
+    related.push(candidate);
+  }
+  if (
+    [...imported].some(
+      (name) =>
+        !related.some((file) => matchesReference(new Set([name]), file.path)),
+    )
+  ) {
+    partial = true;
+  }
+  while (
+    related.length > 0 &&
+    !stateFitsBudget(buildFileState(path, body, kind, lines, related, partial))
+  ) {
+    related.pop();
+    partial = true;
+  }
+  const state = buildFileState(path, body, kind, lines, related, partial);
+  return stateFitsBudget(state) ? state : undefined;
+}
+
+function scanSourceFiles(cwd: string, editedPath: string): ScanResult {
+  const root = realpathSync(cwd);
+  const candidates: Candidate[] = [];
+  let visited = 0;
+  let partial = false;
+
+  function visit(
+    directory: string,
+    depth: number,
+    patterns: readonly string[],
+  ): void {
+    if (depth > MAX_SCAN_DEPTH || visited >= MAX_SCAN_FILES) {
+      partial = true;
+      return;
+    }
+    const localPatterns = [...patterns, ...readIgnorePatterns(directory, root)];
+    const matcher = ignore().add(localPatterns);
+    const entries = readdirSync(directory, { withFileTypes: true }).sort(
+      (a, b) => compareText(a.name, b.name),
+    );
+    for (const entry of entries) {
+      if (visited >= MAX_SCAN_FILES) {
+        partial = true;
+        return;
+      }
+      const absolute = join(directory, entry.name);
+      const path = relative(root, absolute).split(sep).join('/');
+      if (entry.name.startsWith('.') || SENSITIVE_NAME.test(entry.name)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        if (!SKIP_DIRECTORIES.has(entry.name) && !matcher.ignores(`${path}/`)) {
+          visit(absolute, depth + 1, localPatterns);
+        }
+        continue;
+      }
+      if (
+        !entry.isFile() ||
+        matcher.ignores(path) ||
+        path === editedPath ||
+        languageForPath(path) === LANGUAGE.generic
+      ) {
+        continue;
+      }
+      visited += 1;
+      if (statSync(absolute).size > MAX_CANDIDATE_BYTES) {
+        partial = true;
+        continue;
+      }
+      candidates.push({ path, body: readFileSync(absolute, 'utf8') });
+    }
+  }
+
+  visit(root, 0, []);
+  return { candidates, partial };
+}
+
+function readIgnorePatterns(directory: string, root: string): string[] {
+  const prefix = relative(root, directory).split(sep).join('/');
+  const rules: string[] = [];
+  for (const name of IGNORE_FILES) {
+    const file = join(directory, name);
+    if (!exists(file)) {
+      continue;
+    }
+    for (const line of readFileSync(file, 'utf8').split(/\r?\n/u)) {
+      const trimmed = line.trim();
+      if (!trimmed || (trimmed.startsWith('#') && !trimmed.startsWith('\\#'))) {
+        continue;
+      }
+      const negative = line.startsWith('!');
+      const pattern = (negative ? line.slice(1) : line).replace(/^\//u, '');
+      rules.push(
+        `${negative ? '!' : ''}${prefix ? `${prefix}/` : ''}${pattern}`,
+      );
+    }
+  }
+  return rules;
+}
+
+function exists(path: string): boolean {
+  try {
+    statSync(path);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+      return false;
+    }
+    throw error;
+  }
+}
+
+function modulePath(path: string): string {
+  const extension = extname(path);
+  const withoutExtension = extension ? path.slice(0, -extension.length) : path;
+  return withoutExtension.endsWith('/index')
+    ? withoutExtension.slice(0, -'/index'.length)
+    : withoutExtension;
+}
+
+function references(path: string, body: string): Set<string> {
+  const names = new Set<string>();
+  const language = languageForPath(path);
+  const code = body.replace(/\/\*[\s\S]*?\*\/|^[ \t]*\/\/[^\n]*$/gmu, '');
+  if (language === LANGUAGE.typescript || language === LANGUAGE.javascript) {
+    const imports = [
+      /^[ \t]*(?:import|export)\s+(?:\{[^}]*\}|[^\n;]+)\s*from\s*['"](\.[^'"]+)['"]/gmu,
+      /^[ \t]*import\s*['"](\.[^'"]+)['"]/gmu,
+      /^[ \t]*(?:(?:const|let|var)\s+[\w{} ,]+\s*=\s*)?require\s*\(\s*['"](\.[^'"]+)['"]/gmu,
+    ];
+    for (const pattern of imports) {
+      for (const match of code.matchAll(pattern)) {
+        const specifier = match[1];
+        if (specifier) {
+          names.add(
+            modulePath(
+              posix.normalize(posix.join(posix.dirname(path), specifier)),
+            ),
+          );
+        }
+      }
+    }
+  }
+  if (language === LANGUAGE.python) {
+    for (const match of code.matchAll(
+      /^[ \t]*from\s+(\.+)([\w.]*)\s+import\b/gmu,
+    )) {
+      const dots = match[1]?.length ?? 0;
+      const specifier = match[2]?.replaceAll('.', '/') ?? '';
+      const parent = posix.resolve(
+        '/',
+        posix.dirname(path),
+        ...Array(dots - 1).fill('..'),
+      );
+      names.add(modulePath(posix.join(parent.slice(1), specifier)));
+    }
+  }
+  if (language === LANGUAGE.rust) {
+    let sourceRoot = posix.dirname(path);
+    if (path.startsWith('src/')) {
+      sourceRoot = 'src';
+    } else if (path.includes('/src/')) {
+      sourceRoot = path.slice(0, path.indexOf('/src/') + '/src'.length);
+    }
+    for (const match of code.matchAll(
+      /^[ \t]*(?:pub\s+)?(?:use|mod)\s+(crate::)?([\w:]+)\s*[;{]/gmu,
+    )) {
+      const specifier = match[2]?.replaceAll('::', '/');
+      if (specifier) {
+        const from = match[1] ? sourceRoot : posix.dirname(path);
+        names.add(modulePath(posix.join(from, specifier)));
+      }
+    }
+  }
+  if (language === LANGUAGE.php) {
+    for (const match of code.matchAll(
+      /^[ \t]*(?:require|include)(?:_once)?\s*(?:\(?\s*__DIR__\s*\.\s*)?['"](\.[^'"]+|\/[^'"]+)['"]/gmu,
+    )) {
+      const specifier = match[1];
+      if (specifier) {
+        names.add(
+          modulePath(
+            posix.normalize(posix.join(posix.dirname(path), specifier)),
+          ),
+        );
+      }
+    }
+  }
+  if (language === LANGUAGE.java) {
+    for (const match of code.matchAll(
+      /^[ \t]*import\s+(?:static\s+)?([\w.]+)\s*;/gmu,
+    )) {
+      const specifier = match[1]?.replaceAll('.', '/');
+      if (specifier) {
+        names.add(specifier);
+      }
+    }
+  }
+  if (language === LANGUAGE.go) {
+    for (const declaration of code.matchAll(
+      /^[ \t]*import\s*(?:\(([^)]*)\)|"([^"\n]+)")/gmu,
+    )) {
+      const quoted = declaration[1] ?? `"${declaration[2] ?? ''}"`;
+      for (const match of quoted.matchAll(/"([^"\n]+)"/gu)) {
+        if (match[1]) {
+          names.add(match[1]);
+        }
+      }
+    }
+  }
+  return names;
+}
+
+function compareText(left: string, right: string): number {
+  if (left < right) {
+    return -1;
+  }
+  if (left > right) {
+    return 1;
+  }
+  return 0;
+}
+
+function matchesReference(names: ReadonlySet<string>, path: string): boolean {
+  const target = modulePath(path);
+  if (names.has(target)) {
+    return true;
+  }
+  for (const name of names) {
+    if (path.endsWith('.java') && target.endsWith(`/${name}`)) {
+      return true;
+    }
+    if (path.endsWith('.go')) {
+      const packageParts = name.split('/');
+      const packageSuffix = packageParts.slice(-2).join('/');
+      if (
+        packageParts.length >= 2 &&
+        posix.dirname(path).endsWith(`/${packageSuffix}`)
+      ) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+// Naming is evidence only for a sibling test, never for a repository-wide basename match.
+function isCompanionTest(source: string, candidate: string): boolean {
+  if (
+    isTestPath(source) ||
+    !isTestPath(candidate) ||
+    posix.dirname(source) !== posix.dirname(candidate)
+  ) {
+    return false;
+  }
+  const stem = posix.basename(source, extname(source));
+  const testStem = posix.basename(candidate, extname(candidate));
+  return (
+    testStem === `${stem}.test` ||
+    testStem === `${stem}.spec` ||
+    testStem === `${stem}_test` ||
+    testStem === `test_${stem}` ||
+    testStem === `${stem}Test`
+  );
+}

package/extensions/jev/guard.ts

@@ -6,6 +6,7 @@ import {
   isWriteToolResult,
   type ToolCallEvent,
 } from '@earendil-works/pi-coding-agent';
+import { commandMatches, detectCheckCommand } from '../done/detect.ts';
 import {
   projectRelativePath,
   resolveFileToolPath,
@@ -14,23 +15,35 @@ import { readFileIfExists } from '../shared/read-file.ts';
 import { REVIEW_NOTE_EVENT, type ReviewNote } from '../shared/review-note.ts';
 import { startsUserTurn } from '../shared/settle.ts';
 import {
-  askJev,
+  askJevRequest,
   JEV_FAILURE,
   type JevFailure,
   type JevTransport,
 } from './client.ts';
+import { buildContextualState } from './context.ts';
 import {
   type AddedLine,
   addedLinesForEdit,
   addedLinesForWrite,
-  buildFileState,
+  buildRequestBody,
   findingKey,
   formatFindings,
   isReviewablePath,
   type JevFinding,
-  stateFitsBudget,
+  type JevRequestBody,
 } from './model.ts';
 
+import {
+  buildAskReview,
+  buildBoardReview,
+  completedItems,
+  completionIds,
+  createWorkflowEvidence,
+  recordFileEvidence,
+  resetWorkflowEvidence,
+  type WorkflowEvidence,
+} from './workflow.ts';
+
 export const JEV_TRANSIENT_FAILURE_LIMIT = 3;
 
 const MUTATION_KIND = {
@@ -65,6 +78,7 @@ export interface JevGuardState {
   rateLimitedThisTurn: boolean;
   lastModel: string | undefined;
   calls: number;
+  readonly evidence: WorkflowEvidence;
   readonly pending: Map<string, PendingMutation>;
   readonly notedThisTurn: Set<string>;
 }
@@ -82,6 +96,7 @@ export function createJevGuardState(): JevGuardState {
     rateLimitedThisTurn: false,
     lastModel: undefined,
     calls: 0,
+    evidence: createWorkflowEvidence(),
     pending: new Map(),
     notedThisTurn: new Set(),
   };
@@ -89,6 +104,7 @@ export function createJevGuardState(): JevGuardState {
 
 // The F10 screen calls this after the user stores a key or asks to retry.
 export function resetJevGuard(state: JevGuardState): void {
+  resetWorkflowEvidence(state.evidence);
   state.halted = undefined;
   state.transientFailures = 0;
   state.rateLimitedThisTurn = false;
@@ -97,6 +113,7 @@ export function resetJevGuard(state: JevGuardState): void {
 // Usage and per-turn memory belong to the active session: a new session starts
 // counting from zero. The breaker stays, because it tracks the key.
 export function resetJevSession(state: JevGuardState): void {
+  resetWorkflowEvidence(state.evidence);
   state.calls = 0;
   state.rateLimitedThisTurn = false;
   state.pending.clear();
@@ -132,6 +149,7 @@ export function registerJevGuard(
     if (!startsUserTurn(event)) {
       return;
     }
+    resetWorkflowEvidence(state.evidence);
     state.notedThisTurn.clear();
     state.rateLimitedThisTurn = false;
   });
@@ -146,7 +164,7 @@ export function registerJevGuard(
   // the previous content is gone. The body is read after, from disk.
   pi.on('tool_call', (event, ctx) => {
     const mutation = extractMutation(event, ctx.cwd);
-    if (mutation === undefined || !isWorthAsking(mutation)) {
+    if (mutation === undefined || !isReviewablePath(mutation.relativePath)) {
       return undefined;
     }
     state.pending.set(event.toolCallId, mutation);
@@ -156,44 +174,108 @@ export function registerJevGuard(
   pi.on('tool_result', async (event, ctx) => {
     const pending = state.pending.get(event.toolCallId);
     state.pending.delete(event.toolCallId);
-    if (pending === undefined || event.isError) {
-      return undefined;
-    }
-    if (!isWriteToolResult(event) && !isEditToolResult(event)) {
-      return undefined;
-    }
-
     const apiKey = dependencies.apiKey();
-    if (apiKey === undefined) {
-      dependencies.report(JEV_STATUS.noKey, ctx);
+    if (
+      apiKey === undefined ||
+      !shouldCallJev(state) ||
+      ctx.signal?.aborted === true
+    ) {
+      if (!event.isError && pending !== undefined && isWorthAsking(pending)) {
+        dependencies.report(
+          apiKey === undefined ? JEV_STATUS.noKey : guardStatus(state),
+          ctx,
+        );
+      }
       return undefined;
     }
-    if (!shouldCallJev(state)) {
-      dependencies.report(guardStatus(state), ctx);
+    if (event.isError) {
+      if (
+        event.toolName === 'bash' &&
+        typeof event.input.command === 'string'
+      ) {
+        const check = detectCheckCommand(ctx.cwd);
+        if (check !== undefined && commandMatches(event.input.command, check)) {
+          state.evidence.checks = 'failed';
+        }
+      }
       return undefined;
     }
-
-    const body = readFileIfExists(pending.absolutePath);
-    if (body === undefined) {
+    if (event.toolName === 'bash' && typeof event.input.command === 'string') {
+      const check = detectCheckCommand(ctx.cwd);
+      if (check !== undefined && commandMatches(event.input.command, check)) {
+        state.evidence.checks = 'passed';
+      }
       return undefined;
     }
-    const fileState = buildFileState(
-      pending.relativePath,
-      body,
-      pending.kind,
-      pending.lines,
-    );
-    if (!stateFitsBudget(fileState) || ctx.signal?.aborted === true) {
+    let requestBody: JevRequestBody | undefined;
+    let subject: string;
+    if (event.toolName === 'sideroom_ask') {
+      if (
+        typeof event.details !== 'object' ||
+        event.details === null ||
+        !('cancelled' in event.details) ||
+        event.details.cancelled !== false
+      ) {
+        return undefined;
+      }
+      requestBody = buildAskReview(event.input);
+      subject = 'sideroom_ask';
+    } else if (event.toolName === 'sideroom_todo') {
+      const items = completedItems(event.details);
+      if (items === undefined) {
+        return undefined;
+      }
+      requestBody = buildBoardReview({
+        items,
+        evidence: state.evidence,
+        changedIds: completionIds(event.input),
+      });
+      subject = 'sideroom_todo';
+    } else {
+      if (
+        pending === undefined ||
+        (!isWriteToolResult(event) && !isEditToolResult(event))
+      ) {
+        return undefined;
+      }
+      subject = pending.relativePath;
+      state.evidence.checks = 'stale';
+      // Replace cached evidence even when this version no longer fits the budget.
+      state.evidence.files.delete(subject);
+      if (!isWorthAsking(pending)) {
+        state.evidence.partial = true;
+        return undefined;
+      }
+      const body = readFileIfExists(pending.absolutePath);
+      if (body === undefined) {
+        state.evidence.partial = true;
+        return undefined;
+      }
+      const fileState = buildContextualState(
+        ctx.cwd,
+        subject,
+        body,
+        pending.kind,
+        pending.lines,
+      );
+      if (fileState === undefined) {
+        state.evidence.partial = true;
+        return undefined;
+      }
+      recordFileEvidence(state.evidence, fileState);
+      requestBody = buildRequestBody(fileState);
+    }
+    if (requestBody === undefined) {
       return undefined;
     }
 
     state.calls += 1;
-    const attempt = await askJev(
-      dependencies.transport,
+    const attempt = await askJevRequest({
+      transport: dependencies.transport,
       apiKey,
-      fileState,
-      ctx.signal,
-    );
+      requestBody,
+      signal: ctx.signal,
+    });
     if (attempt.failure !== undefined) {
       registerFailure(state, attempt.failure);
       dependencies.report(guardStatus(state), ctx);
@@ -208,14 +290,14 @@ export function registerJevGuard(
 
     const findings = attempt.findings ?? [];
     const fresh = findings.filter((finding) =>
-      isUnnoted(state, pending.relativePath, finding),
+      isUnnoted(state, subject, finding),
     );
     if (fresh.length === 0) {
       return undefined;
     }
-    markNoted(state, pending.relativePath, fresh);
+    markNoted(state, subject, fresh);
     const note: ReviewNote = {
-      text: formatFindings(pending.relativePath, fresh),
+      text: formatFindings(subject, fresh),
     };
     pi.events.emit(REVIEW_NOTE_EVENT, note);
     return undefined;
@@ -269,7 +351,7 @@ function registerSuccess(state: JevGuardState): void {
   state.transientFailures = 0;
 }
 
-// A deletion-only edit leaves nothing for the six questions to read, and only
+// A deletion-only edit leaves nothing for the questions to read, and only
 // the project-relative path of a supported language may leave the machine.
 function isWorthAsking(mutation: PendingMutation): boolean {
   return mutation.lines.length > 0 && isReviewablePath(mutation.relativePath);