@rmrdeveloper/sideroom-pi 8.9.0 → 8.11.0

package/extensions/jev/context.ts

@@ -0,0 +1,327 @@
+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,
+  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,
+      );
+      if (!importedByTarget && !consumesTarget) {
+        return [];
+      }
+      return [
+        {
+          ...candidate,
+          relation: importedByTarget ? 'imported' : 'consumer',
+        } as const,
+      ];
+    })
+    .sort((left, right) => {
+      if (left.relation !== right.relation) {
+        return left.relation === 'imported' ? -1 : 1;
+      }
+      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;
+}

package/extensions/jev/guard.ts

@@ -6,23 +6,28 @@ import {
   isWriteToolResult,
   type ToolCallEvent,
 } from '@earendil-works/pi-coding-agent';
-import { resolveFileToolPath } from '../shared/file-path.ts';
+import {
+  projectRelativePath,
+  resolveFileToolPath,
+} from '../shared/file-path.ts';
 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,
   JEV_FAILURE,
   type JevFailure,
   type JevTransport,
 } from './client.ts';
+import { buildContextualState } from './context.ts';
 import {
   type AddedLine,
   addedLinesForEdit,
   addedLinesForWrite,
-  buildFileState,
   findingKey,
   formatFindings,
+  isReviewablePath,
   type JevFinding,
-  stateFitsBudget,
 } from './model.ts';
 
 export const JEV_TRANSIENT_FAILURE_LIMIT = 3;
@@ -37,13 +42,18 @@ export const JEV_STATUS = {
   noKey: 'noKey',
   quota: 'quota',
   auth: 'auth',
+  rateLimited: 'rateLimited',
   unavailable: 'unavailable',
 } as const;
 
 export type JevStatus = (typeof JEV_STATUS)[keyof typeof JEV_STATUS];
 
-interface PendingMutation {
-  readonly path: string;
+interface MutationTarget {
+  readonly absolutePath: string;
+  readonly relativePath: string;
+}
+
+interface PendingMutation extends MutationTarget {
   readonly kind: string;
   readonly lines: readonly AddedLine[];
 }
@@ -51,6 +61,7 @@ interface PendingMutation {
 export interface JevGuardState {
   halted: JevStatus | undefined;
   transientFailures: number;
+  rateLimitedThisTurn: boolean;
   lastModel: string | undefined;
   calls: number;
   readonly pending: Map<string, PendingMutation>;
@@ -67,6 +78,7 @@ export function createJevGuardState(): JevGuardState {
   return {
     halted: undefined,
     transientFailures: 0,
+    rateLimitedThisTurn: false,
     lastModel: undefined,
     calls: 0,
     pending: new Map(),
@@ -78,17 +90,25 @@ export function createJevGuardState(): JevGuardState {
 export function resetJevGuard(state: JevGuardState): void {
   state.halted = undefined;
   state.transientFailures = 0;
+  state.rateLimitedThisTurn = false;
 }
 
-// Usage belongs to the active session: a new session starts counting from zero.
-export function resetJevUsage(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 {
   state.calls = 0;
+  state.rateLimitedThisTurn = false;
+  state.pending.clear();
+  state.notedThisTurn.clear();
 }
 
 export function guardStatus(state: JevGuardState): JevStatus {
   if (state.halted !== undefined) {
     return state.halted;
   }
+  if (state.rateLimitedThisTurn) {
+    return JEV_STATUS.rateLimited;
+  }
   return state.transientFailures > 0
     ? JEV_STATUS.unavailable
     : JEV_STATUS.ready;
@@ -97,6 +117,7 @@ export function guardStatus(state: JevGuardState): JevStatus {
 export function shouldCallJev(state: JevGuardState): boolean {
   return (
     state.halted === undefined &&
+    !state.rateLimitedThisTurn &&
     state.transientFailures < JEV_TRANSIENT_FAILURE_LIMIT
   );
 }
@@ -107,17 +128,24 @@ export function registerJevGuard(
   dependencies: JevGuardDependencies,
 ): void {
   pi.on('input', (event) => {
-    if (event.source !== 'interactive' && event.source !== 'rpc') {
+    if (!startsUserTurn(event)) {
       return;
     }
     state.notedThisTurn.clear();
+    state.rateLimitedThisTurn = false;
+  });
+
+  // A call another extension blocks in tool_call never reaches tool_result,
+  // and every result of a turn lands before its turn_end.
+  pi.on('turn_end', () => {
+    state.pending.clear();
   });
 
   // The added lines are read before the mutation lands, because after a write
   // 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) {
+    if (mutation === undefined || !isWorthAsking(mutation)) {
       return undefined;
     }
     state.pending.set(event.toolCallId, mutation);
@@ -144,8 +172,21 @@ export function registerJevGuard(
       return undefined;
     }
 
-    const body = readMutationBody(ctx.cwd, pending.path);
-    if (body === undefined || !stateFitsBudget(body)) {
+    const body = readFileIfExists(pending.absolutePath);
+    if (body === undefined) {
+      return undefined;
+    }
+    if (ctx.signal?.aborted === true) {
+      return undefined;
+    }
+    const fileState = buildContextualState(
+      ctx.cwd,
+      pending.relativePath,
+      body,
+      pending.kind,
+      pending.lines,
+    );
+    if (fileState === undefined) {
       return undefined;
     }
 
@@ -153,7 +194,8 @@ export function registerJevGuard(
     const attempt = await askJev(
       dependencies.transport,
       apiKey,
-      buildFileState(pending.path, body, pending.kind, pending.lines),
+      fileState,
+      ctx.signal,
     );
     if (attempt.failure !== undefined) {
       registerFailure(state, attempt.failure);
@@ -169,18 +211,17 @@ export function registerJevGuard(
 
     const findings = attempt.findings ?? [];
     const fresh = findings.filter((finding) =>
-      isUnnoted(state, pending.path, finding),
+      isUnnoted(state, pending.relativePath, finding),
     );
     if (fresh.length === 0) {
       return undefined;
     }
-    markNoted(state, pending.path, fresh);
-    return {
-      content: [
-        ...event.content,
-        { type: 'text' as const, text: formatFindings(pending.path, fresh) },
-      ],
+    markNoted(state, pending.relativePath, fresh);
+    const note: ReviewNote = {
+      text: formatFindings(pending.relativePath, fresh),
     };
+    pi.events.emit(REVIEW_NOTE_EVENT, note);
+    return undefined;
   });
 }
 
@@ -202,7 +243,16 @@ function markNoted(
   }
 }
 
+// A user abort says nothing about the service, and a rate limit clears on its
+// own, so neither may count toward switching Jev off.
 function registerFailure(state: JevGuardState, failure: JevFailure): void {
+  if (failure === JEV_FAILURE.cancelled) {
+    return;
+  }
+  if (failure === JEV_FAILURE.rateLimited) {
+    state.rateLimitedThisTurn = true;
+    return;
+  }
   if (failure === JEV_FAILURE.quota) {
     state.halted = JEV_STATUS.quota;
     return;
@@ -222,24 +272,37 @@ function registerSuccess(state: JevGuardState): void {
   state.transientFailures = 0;
 }
 
+// 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);
+}
+
 function extractMutation(
   event: ToolCallEvent,
   cwd: string,
 ): PendingMutation | undefined {
   if (isToolCallEventType('write', event)) {
-    const absolutePath = resolveFileToolPath(cwd, event.input.path);
+    const target = resolveTarget(cwd, event.input.path);
+    if (target === undefined) {
+      return undefined;
+    }
     return {
-      path: event.input.path,
+      ...target,
       kind: MUTATION_KIND.write,
       lines: addedLinesForWrite(
-        absolutePath === undefined ? undefined : readFileIfExists(absolutePath),
+        readFileIfExists(target.absolutePath),
         event.input.content,
       ),
     };
   }
   if (isToolCallEventType('edit', event)) {
+    const target = resolveTarget(cwd, event.input.path);
+    if (target === undefined) {
+      return undefined;
+    }
     return {
-      path: event.input.path,
+      ...target,
       kind: MUTATION_KIND.edit,
       lines: addedLinesForEdit(event.input.edits),
     };
@@ -247,10 +310,14 @@ function extractMutation(
   return undefined;
 }
 
-function readMutationBody(cwd: string, path: string): string | undefined {
+function resolveTarget(cwd: string, path: string): MutationTarget | undefined {
   const absolutePath = resolveFileToolPath(cwd, path);
   if (absolutePath === undefined) {
     return undefined;
   }
-  return readFileIfExists(absolutePath);
+  const relativePath = projectRelativePath(cwd, absolutePath);
+  if (relativePath === undefined) {
+    return undefined;
+  }
+  return { absolutePath, relativePath };
 }

package/extensions/jev/index.ts

@@ -11,7 +11,7 @@ import {
   type JevStatus,
   registerJevGuard,
   resetJevGuard,
-  resetJevUsage,
+  resetJevSession,
 } from './guard.ts';
 import {
   clearStoredKey,
@@ -75,7 +75,7 @@ export default function registerJev(pi: ExtensionAPI): void {
   });
 
   pi.on('session_start', (_event, ctx) => {
-    resetJevUsage(guardState);
+    resetJevSession(guardState);
     publish(currentStatus(), ctx);
   });