@dreb/coding-agent 2.30.1 → 2.31.1

package/dist/core/agent-session.js

@@ -12,7 +12,7 @@
  *
  * Modes use this class and add their own I/O layer on top.
  */
-import { copyFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, realpathSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { isContextOverflow, modelsAreEqual, resetApiProviders, supportsXhigh } from "@dreb/ai";
@@ -28,6 +28,7 @@ import { ExtensionRunner, wrapRegisteredTools, } from "./extensions/index.js";
 import { checkScriptContent, extractScriptPaths, isForbiddenCommand } from "./forbidden-commands.js";
 import { getGitRepoState } from "./git-repo-state.js";
 import { log } from "./logger.js";
+import { computeNestedContextBlock } from "./nested-context.js";
 import { PerformanceTracker } from "./performance-tracker.js";
 import { expandPromptTemplate } from "./prompt-templates.js";
 import { scrubSecrets } from "./secret-scrubber.js";
@@ -106,6 +107,14 @@ export class AgentSession {
     _customTools;
     _baseToolDefinitions = new Map();
     _cwd;
+    /**
+     * Per-session realpaths of context files already loaded (seeded lazily from the
+     * session-start context set). Ensures each nested AGENTS.md/CLAUDE.md is injected
+     * at most once. `undefined` until first use.
+     */
+    _nestedContextLoaded;
+    /** Negative cache of target directories already scanned for nested context. */
+    _nestedContextScannedDirs = new Set();
     _extensionRunnerRef;
     _initialActiveToolNames;
     _baseToolsOverride;
@@ -301,8 +310,16 @@ export class AgentSession {
             if (totalRedactions > 0) {
                 scrubOverride = { content: scrubbedContent };
             }
+            // Nested-context auto-load: cache-safe injection that rides on the tool result
+            // (does not rebuild the system prompt). Computed once per tool call.
+            const nestedBlock = this._computeNestedContextBlock(toolCall.name, args);
+            const scrubbedNestedBlock = nestedBlock ? scrubSecrets(nestedBlock, compiledExtras).scrubbed : null;
+            const withNested = (base) => scrubbedNestedBlock ? [...base, { type: "text", text: scrubbedNestedBlock }] : base;
             const runner = this._extensionRunner;
             if (!runner?.hasHandlers("tool_result")) {
+                if (nestedBlock) {
+                    return { content: withNested(scrubbedContent), details: scrubOverride?.details };
+                }
                 return scrubOverride;
             }
             const hookResult = await runner.emitToolResult({
@@ -315,14 +332,53 @@ export class AgentSession {
                 isError,
             });
             if (!hookResult || isError) {
+                if (nestedBlock) {
+                    return { content: withNested(scrubbedContent), details: scrubOverride?.details };
+                }
                 return scrubOverride;
             }
+            const finalContent = hookResult.content ?? scrubOverride?.content;
+            if (nestedBlock) {
+                return { content: withNested(finalContent ?? scrubbedContent), details: hookResult.details };
+            }
             return {
-                content: hookResult.content ?? scrubOverride?.content,
+                content: finalContent,
                 details: hookResult.details,
             };
         });
     }
+    /**
+     * Compute a nested-context injection block for a tool call, or `null` when nothing
+     * should be injected. Resolves the directory the tool operates in, walks up to a
+     * sensible ceiling collecting not-yet-loaded AGENTS.md/CLAUDE.md files, and formats
+     * them. Each directory is scanned at most once (negative cache) and each file is
+     * injected at most once per session (realpath dedup). Gated by `context.autoLoadNested`.
+     */
+    _computeNestedContextBlock(toolName, args) {
+        const enabled = this.settingsManager?.getAutoLoadNestedContext() ?? true;
+        if (!enabled)
+            return null;
+        // Seed the per-session loaded set from the context files loaded at session start so
+        // ancestor files are never re-injected.
+        if (!this._nestedContextLoaded) {
+            this._nestedContextLoaded = new Set();
+            for (const file of this._resourceLoader.getAgentsFiles().agentsFiles) {
+                try {
+                    this._nestedContextLoaded.add(realpathSync(file.path));
+                }
+                catch {
+                    this._nestedContextLoaded.add(file.path);
+                }
+            }
+        }
+        const state = {
+            enabled,
+            cwd: this._cwd,
+            loaded: this._nestedContextLoaded,
+            scannedDirs: this._nestedContextScannedDirs,
+        };
+        return computeNestedContextBlock(toolName, args, state);
+    }
     /**
      * Install guardrails for background agent interactions:
      * - Layer B: Sentinel monitor — steer if the parent model generates suspicious tokens