sentinelayer-cli 0.4.5 → 0.8.0

package/src/agents/jules/tools/dispatch.js

@@ -4,6 +4,7 @@ import {
   normalizeRunEvent,
   appendRunEvent,
 } from "../../../telemetry/ledger.js";
+import { createAgentEvent } from "../../../events/schema.js";
 import { fileRead } from "./file-read.js";
 import { grep } from "./grep.js";
 import { glob } from "./glob.js";
@@ -78,8 +79,7 @@ export async function dispatchTool(toolName, input, ctx) {
     await safeAppendEvent(ctx, stopEvent);
 
     if (ctx.onEvent) {
-      ctx.onEvent({
-        stream: "sl_event",
+      ctx.onEvent(createAgentEvent({
         event: "budget_stop",
         agent: ctx.agentIdentity,
         payload: {
@@ -87,7 +87,9 @@ export async function dispatchTool(toolName, input, ctx) {
           reasons: budgetCheck.reasons,
         },
         usage: snapshotUsage(ctx),
-      });
+        sessionId: ctx.sessionId,
+        runId: ctx.runId,
+      }));
     }
 
     throw new BudgetExhaustedError(budgetCheck);
@@ -95,13 +97,14 @@ export async function dispatchTool(toolName, input, ctx) {
 
   // Emit budget warnings
   if (budgetCheck.warnings.length > 0 && ctx.onEvent) {
-    ctx.onEvent({
-      stream: "sl_event",
+    ctx.onEvent(createAgentEvent({
       event: "budget_warning",
       agent: ctx.agentIdentity,
       payload: { warnings: budgetCheck.warnings },
       usage: snapshotUsage(ctx),
-    });
+      sessionId: ctx.sessionId,
+      runId: ctx.runId,
+    }));
   }
 
   // 2. Emit tool_call event
@@ -121,13 +124,14 @@ export async function dispatchTool(toolName, input, ctx) {
   await safeAppendEvent(ctx, callEvent);
 
   if (ctx.onEvent) {
-    ctx.onEvent({
-      stream: "sl_event",
+    ctx.onEvent(createAgentEvent({
       event: "tool_call",
       agent: ctx.agentIdentity,
       payload: { tool: toolName, input: sanitizeInput(toolName, input) },
       usage: snapshotUsage(ctx),
-    });
+      sessionId: ctx.sessionId,
+      runId: ctx.runId,
+    }));
   }
 
   // 3. Execute
@@ -147,6 +151,12 @@ export async function dispatchTool(toolName, input, ctx) {
   ctx.lastToolCallAt = Date.now();
   ctx.lastToolName = toolName;
 
+  // Track confirmed file reads for coverage accounting
+  if (!error && toolName === "FileRead") {
+    const readPath = input?.file_path || input?.filePath || input?.path || "";
+    if (readPath) ctx.usage.filesRead.add(readPath);
+  }
+
   // 5. Emit tool_result event
   const resultEvent = {
     eventType: "tool_call",
@@ -168,8 +178,7 @@ export async function dispatchTool(toolName, input, ctx) {
   await safeAppendEvent(ctx, resultEvent);
 
   if (ctx.onEvent) {
-    ctx.onEvent({
-      stream: "sl_event",
+    ctx.onEvent(createAgentEvent({
       event: "tool_result",
       agent: ctx.agentIdentity,
       payload: {
@@ -179,7 +188,9 @@ export async function dispatchTool(toolName, input, ctx) {
         error: error?.message,
       },
       usage: snapshotUsage(ctx),
-    });
+      sessionId: ctx.sessionId,
+      runId: ctx.runId,
+    }));
   }
 
   if (error) throw error;
@@ -248,6 +259,7 @@ export function createAgentContext({
       outputTokens: 0,
       toolCalls: 0,
       runtimeMs: 0,
+      filesRead: new Set(),
     },
     sessionId: sessionId || randomUUID(),
     runId: runId || `jules-${Date.now()}-${randomUUID().slice(0, 8)}`,
@@ -265,6 +277,7 @@ function snapshotUsage(ctx) {
     outputTokens: ctx.usage.outputTokens,
     toolCalls: ctx.usage.toolCalls,
     durationMs: Date.now() - ctx.startedAt,
+    filesRead: [...(ctx.usage.filesRead || [])],
   };
 }
 

package/src/agents/jules/tools/file-edit.js

@@ -1,180 +1,2 @@
-import fs from "node:fs";
-import path from "node:path";
-import { createHash } from "node:crypto";
-import { PathGuardError, resolveGuardedPath } from "./path-guards.js";
-
-/**
- * String replacement in files with uniqueness enforcement and diff generation.
- * Designed for use inside a worktree — validates path is within allowed directory.
- *
- * @param {object} input
- * @param {string} input.file_path - Absolute path to the file to modify.
- * @param {string} input.old_string - Exact text to replace.
- * @param {string} input.new_string - Replacement text (must differ from old_string).
- * @param {boolean} [input.replace_all] - Replace all occurrences (default: false).
- * @param {string} [input.allowed_root] - Root directory edits are permitted in (worktree guard).
- * @returns {{ filePath, diff, occurrencesFound, occurrencesReplaced, linesChanged }}
- */
-export function fileEdit(input) {
-  if (!input.old_string && input.old_string !== "") {
-    throw new FileEditError("old_string is required.");
-  }
-  if (input.new_string === undefined || input.new_string === null) {
-    throw new FileEditError("new_string is required.");
-  }
-  if (input.old_string === input.new_string) {
-    throw new FileEditError("old_string and new_string must be different.");
-  }
-
-  let filePath;
-  try {
-    const guarded = resolveGuardedPath({
-      filePath: input.file_path,
-      allowedRoot: input.allowed_root || undefined,
-    });
-    filePath = guarded.resolvedPath;
-  } catch (error) {
-    if (error instanceof PathGuardError) {
-      throw new FileEditError(error.message);
-    }
-    if (error instanceof FileEditError) {
-      throw error;
-    }
-    throw new FileEditError(`Cannot access path: ${error.message}`);
-  }
-
-  // Read current content
-  let content;
-  try {
-    content = fs.readFileSync(filePath, "utf-8");
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      throw new FileEditError(`File not found: ${filePath}`);
-    }
-    throw new FileEditError(`Cannot read file: ${err.message}`);
-  }
-
-  // Count occurrences
-  const occurrences = countOccurrences(content, input.old_string);
-  if (occurrences === 0) {
-    throw new FileEditError(
-      `old_string not found in ${filePath}. Verify the exact text including whitespace and indentation.`,
-    );
-  }
-  if (occurrences > 1 && !input.replace_all) {
-    throw new FileEditError(
-      `old_string found ${occurrences} times in ${filePath}. Use replace_all: true to replace all, or provide more surrounding context to make it unique.`,
-    );
-  }
-
-  // Perform replacement
-  const replaceCount = input.replace_all ? occurrences : 1;
-  let newContent;
-  if (input.replace_all) {
-    newContent = content.split(input.old_string).join(input.new_string);
-  } else {
-    const idx = content.indexOf(input.old_string);
-    newContent =
-      content.slice(0, idx) +
-      input.new_string +
-      content.slice(idx + input.old_string.length);
-  }
-
-  // Generate unified diff for display
-  const diff = generateUnifiedDiff(filePath, content, newContent);
-
-  // Count changed lines
-  const oldLines = content.split("\n").length;
-  const newLines = newContent.split("\n").length;
-  const linesChanged = Math.abs(newLines - oldLines) +
-    countDiffLines(content, newContent);
-
-  // Write atomically: temp file + rename
-  const tmpPath = filePath + `.sl-edit-${Date.now()}`;
-  fs.writeFileSync(tmpPath, newContent, "utf-8");
-  fs.renameSync(tmpPath, filePath);
-
-  return {
-    filePath,
-    diff,
-    occurrencesFound: occurrences,
-    occurrencesReplaced: replaceCount,
-    linesChanged,
-    beforeHash: hashContent(content),
-    afterHash: hashContent(newContent),
-  };
-}
-
-function countOccurrences(haystack, needle) {
-  if (!needle) return 0;
-  let count = 0;
-  let idx = 0;
-  while ((idx = haystack.indexOf(needle, idx)) !== -1) {
-    count++;
-    idx += needle.length;
-  }
-  return count;
-}
-
-function generateUnifiedDiff(filePath, oldContent, newContent) {
-  const oldLines = oldContent.split("\n");
-  const newLines = newContent.split("\n");
-  const diffLines = [];
-
-  diffLines.push(`--- a/${path.basename(filePath)}`);
-  diffLines.push(`+++ b/${path.basename(filePath)}`);
-
-  // Simple line-by-line diff (not full Myers — sufficient for review display)
-  const maxLines = Math.max(oldLines.length, newLines.length);
-  let chunkStart = -1;
-  let chunkOld = [];
-  let chunkNew = [];
-
-  for (let i = 0; i < maxLines; i++) {
-    const oldLine = i < oldLines.length ? oldLines[i] : undefined;
-    const newLine = i < newLines.length ? newLines[i] : undefined;
-
-    if (oldLine !== newLine) {
-      if (chunkStart === -1) chunkStart = i;
-      if (oldLine !== undefined) chunkOld.push(`-${oldLine}`);
-      if (newLine !== undefined) chunkNew.push(`+${newLine}`);
-    } else if (chunkStart !== -1) {
-      // Flush chunk
-      diffLines.push(`@@ -${chunkStart + 1},${chunkOld.length} +${chunkStart + 1},${chunkNew.length} @@`);
-      diffLines.push(...chunkOld, ...chunkNew);
-      chunkStart = -1;
-      chunkOld = [];
-      chunkNew = [];
-    }
-  }
-
-  // Flush final chunk
-  if (chunkStart !== -1) {
-    diffLines.push(`@@ -${chunkStart + 1},${chunkOld.length} +${chunkStart + 1},${chunkNew.length} @@`);
-    diffLines.push(...chunkOld, ...chunkNew);
-  }
-
-  return diffLines.join("\n");
-}
-
-function countDiffLines(oldContent, newContent) {
-  const oldLines = oldContent.split("\n");
-  const newLines = newContent.split("\n");
-  let changed = 0;
-  const max = Math.min(oldLines.length, newLines.length);
-  for (let i = 0; i < max; i++) {
-    if (oldLines[i] !== newLines[i]) changed++;
-  }
-  return changed;
-}
-
-function hashContent(content) {
-  return createHash("sha256").update(content).digest("hex").slice(0, 16);
-}
-
-export class FileEditError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "FileEditError";
-  }
-}
+// Re-export from shared tools. FileEdit is not Jules-specific.
+export { fileEdit, FileEditError } from "../../shared-tools/file-edit.js";

package/src/agents/jules/tools/file-read.js

@@ -1,100 +1,2 @@
-import fs from "node:fs";
-import path from "node:path";
-import { PathGuardError, resolveGuardedPath } from "./path-guards.js";
-
-const MAX_RESULT_CHARS = 5000;
-const BINARY_EXTENSIONS = new Set([
-  ".png", ".jpg", ".jpeg", ".gif", ".webp", ".avif", ".ico", ".svg",
-  ".woff", ".woff2", ".ttf", ".eot", ".otf",
-  ".mp3", ".mp4", ".ogg", ".webm", ".wav",
-  ".zip", ".tar", ".gz", ".br", ".zst",
-  ".pdf", ".wasm", ".node", ".exe", ".dll", ".so", ".dylib",
-]);
-
-/**
- * Read a file with line numbers, offset/limit pagination, and binary detection.
- * Returns { filePath, content, numLines, startLine, totalLines, truncated }.
- */
-export function fileRead(input) {
-  const filePath = resolveAndValidatePath(input.file_path, input.allowed_root);
-  const ext = path.extname(filePath).toLowerCase();
-
-  if (BINARY_EXTENSIONS.has(ext)) {
-    const stat = fs.statSync(filePath);
-    return {
-      filePath,
-      content: `[Binary file: ${ext}, ${stat.size} bytes. Use a specialized viewer.]`,
-      numLines: 0,
-      startLine: 0,
-      totalLines: 0,
-      truncated: false,
-      binary: true,
-    };
-  }
-
-  let raw;
-  try {
-    raw = fs.readFileSync(filePath, "utf-8");
-  } catch (err) {
-    if (err.code === "ENOENT") {
-      throw new FileReadError(`File not found: ${filePath}`);
-    }
-    if (err.code === "EISDIR") {
-      throw new FileReadError(`Path is a directory, not a file: ${filePath}`);
-    }
-    throw new FileReadError(`Cannot read file: ${err.message}`);
-  }
-
-  const allLines = raw.split("\n");
-  const totalLines = allLines.length;
-  const offset = Math.max(0, input.offset ?? 0);
-  const limit = input.limit ?? 2000;
-  const sliced = allLines.slice(offset, offset + limit);
-  const startLine = offset + 1;
-
-  const numbered = sliced.map(
-    (line, i) => `${String(startLine + i).padStart(6)}\t${line}`,
-  );
-  let content = numbered.join("\n");
-  let truncated = false;
-
-  if (content.length > MAX_RESULT_CHARS) {
-    content = content.slice(0, MAX_RESULT_CHARS) + "\n[... truncated]";
-    truncated = true;
-  }
-
-  return {
-    filePath,
-    content,
-    numLines: sliced.length,
-    startLine,
-    totalLines,
-    truncated,
-    binary: false,
-  };
-}
-
-export class FileReadError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "FileReadError";
-  }
-}
-
-function resolveAndValidatePath(filePath, allowedRoot) {
-  try {
-    const guarded = resolveGuardedPath({
-      filePath,
-      allowedRoot: allowedRoot || undefined,
-    });
-    return guarded.resolvedPath;
-  } catch (error) {
-    if (error instanceof PathGuardError) {
-      throw new FileReadError(error.message);
-    }
-    if (error instanceof FileReadError) {
-      throw error;
-    }
-    throw new FileReadError(`Cannot access path: ${error.message}`);
-  }
-}
+// Re-export from shared tools. FileRead is not Jules-specific.
+export { fileRead, FileReadError } from "../../shared-tools/file-read.js";

package/src/agents/jules/tools/glob.js

@@ -1,168 +1,2 @@
-import fs from "node:fs";
-import path from "node:path";
-
-const MAX_RESULTS = 200;
-const IGNORE_DIRS = new Set([
-  ".git", "node_modules", ".next", "dist", "build", "coverage",
-  ".turbo", ".idea", ".vscode", "__pycache__", ".venv", ".cache",
-  ".parcel-cache", ".svelte-kit", ".nuxt", ".output", ".vercel",
-]);
-
-/**
- * Fast file pattern matching sorted by modification time (newest first).
- *
- * @param {object} input
- * @param {string} input.pattern - Glob pattern (e.g., "**\/*.tsx", "src/**\/*.js").
- * @param {string} [input.path] - Directory to search (default: cwd).
- * @param {number} [input.limit] - Max results (default: 200).
- * @returns {{ filenames, numFiles, truncated, durationMs }}
- */
-export function glob(input) {
-  if (!input.pattern || typeof input.pattern !== "string") {
-    throw new GlobError("pattern is required and must be a non-empty string.");
-  }
-
-  const searchPath = input.path ? path.resolve(input.path) : process.cwd();
-  const limit = input.limit ?? MAX_RESULTS;
-  const startMs = Date.now();
-
-  if (!fs.existsSync(searchPath)) {
-    throw new GlobError(`Directory not found: ${searchPath}`);
-  }
-
-  const stat = fs.statSync(searchPath);
-  if (!stat.isDirectory()) {
-    throw new GlobError(`Path is not a directory: ${searchPath}`);
-  }
-
-  const matcher = buildMatcher(input.pattern);
-  const ignorePatterns = loadIgnorePatterns(searchPath);
-  const results = [];
-
-  walk(searchPath, searchPath, matcher, ignorePatterns, results, limit);
-
-  // Sort by mtime descending (newest first)
-  results.sort((a, b) => b.mtime - a.mtime);
-
-  const truncated = results.length >= limit;
-  const filenames = results.map((r) => r.relativePath);
-
-  return {
-    filenames,
-    numFiles: filenames.length,
-    truncated,
-    durationMs: Date.now() - startMs,
-  };
-}
-
-function walk(rootPath, currentPath, matcher, ignorePatterns, results, limit) {
-  let entries;
-  try {
-    entries = fs.readdirSync(currentPath, { withFileTypes: true });
-  } catch {
-    return; // skip unreadable directories
-  }
-
-  for (const entry of entries) {
-    if (results.length >= limit) return;
-
-    const name = entry.name;
-    if (IGNORE_DIRS.has(name)) continue;
-
-    const fullPath = path.join(currentPath, name);
-    const relativePath = path.relative(rootPath, fullPath);
-
-    if (ignorePatterns.some((p) => p(relativePath))) continue;
-
-    if (entry.isDirectory()) {
-      walk(rootPath, fullPath, matcher, ignorePatterns, results, limit);
-    } else if (entry.isFile() && matcher(relativePath)) {
-      let mtime = 0;
-      try {
-        mtime = fs.statSync(fullPath).mtimeMs;
-      } catch { /* use 0 if stat fails */ }
-      results.push({ relativePath, mtime });
-    }
-  }
-}
-
-/**
- * Build a filename matcher from a glob pattern.
- * Supports: *.ext, **\/*.ext, *.{ext1,ext2}, prefix*, *suffix
- */
-function buildMatcher(pattern) {
-  // Handle brace expansion: *.{ts,tsx} → ["*.ts", "*.tsx"]
-  const expanded = expandBraces(pattern);
-
-  const matchers = expanded.map((p) => {
-    // ** recursive match
-    if (p.includes("**/")) {
-      const suffix = p.split("**/").pop();
-      const suffixMatcher = buildSimpleMatcher(suffix);
-      return (filepath) => {
-        const basename = path.basename(filepath);
-        const segments = filepath.split(path.sep);
-        return segments.some((_, i) =>
-          suffixMatcher(segments.slice(i).join(path.sep)),
-        ) || suffixMatcher(basename);
-      };
-    }
-    return buildSimpleMatcher(p);
-  });
-
-  return (filepath) => matchers.some((m) => m(filepath));
-}
-
-function buildSimpleMatcher(pattern) {
-  if (pattern.startsWith("*.")) {
-    const ext = pattern.slice(1);
-    return (filepath) => filepath.endsWith(ext) || path.basename(filepath).endsWith(ext);
-  }
-  if (pattern.endsWith("*")) {
-    const prefix = pattern.slice(0, -1);
-    return (filepath) => filepath.startsWith(prefix) || path.basename(filepath).startsWith(prefix);
-  }
-  if (pattern.includes("*")) {
-    const regex = new RegExp(
-      "^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*") + "$",
-    );
-    return (filepath) => regex.test(filepath) || regex.test(path.basename(filepath));
-  }
-  return (filepath) => filepath === pattern || path.basename(filepath) === pattern;
-}
-
-function expandBraces(pattern) {
-  const braceMatch = pattern.match(/\{([^}]+)\}/);
-  if (!braceMatch) return [pattern];
-  const alternatives = braceMatch[1].split(",");
-  return alternatives.map((alt) =>
-    pattern.replace(braceMatch[0], alt.trim()),
-  );
-}
-
-function loadIgnorePatterns(rootPath) {
-  const patterns = [];
-  const gitignorePath = path.join(rootPath, ".gitignore");
-  const slignorePath = path.join(rootPath, ".sentinelayerignore");
-
-  for (const ignorePath of [gitignorePath, slignorePath]) {
-    try {
-      const content = fs.readFileSync(ignorePath, "utf-8");
-      for (const line of content.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith("#")) continue;
-        const matcher = buildSimpleMatcher(trimmed);
-        patterns.push(matcher);
-      }
-    } catch { /* ignore missing files */ }
-  }
-
-  return patterns;
-}
-
-export class GlobError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "GlobError";
-  }
-}
+// Re-export from shared tools. Glob is not Jules-specific.
+export { glob, GlobError } from "../../shared-tools/glob.js";