@hicaru/pi-rlm 0.2.2 → 0.3.1

package/src/text/tokens.ts

@@ -25,7 +25,7 @@ export function estimateMessageTokens(messages: { content: string }[]): number {
  * Character length of one context entry. `ContextFile`-shaped entries report their content
  * length; anything else falls back to its serialized form.
  *
- * Deliberately does NOT import `isContextFile` from context/library-context.ts: that module
+ * Deliberately does NOT import `isContextFile` from context/namespace.ts: that module
  * imports `estimateTokens` from here, so the reverse import would be a cycle. `in`-narrowing
  * needs no type guard and no cast.
  */
@@ -74,8 +74,8 @@ const isTokenizedEntry = (v: unknown): v is { readonly tokens: number } =>
   typeof v === "object" && v !== null && typeof (v as { readonly tokens?: unknown }).tokens === "number";
 
 /** Per-file token distribution for a context payload; `undefined` for plain strings or empty arrays.
- *  Handles both serialized ContextFile[] (flat array from serializeForSandbox) and raw ContextBundle
- *  objects ({ files: [...] }) so callers don't need to know which form they received. */
+ *  Handles both a flat ContextFile[] and a raw bundle object ({ files: [...] }) so callers
+ *  don't need to know which form they received. */
 export function contextSizeStats(context: unknown): ContextSizeStats | undefined {
   // Normalise to a flat entry list: accept either a direct array or an object with a .files array.
   const entries: readonly unknown[] = Array.isArray(context)

package/src/tool/repl-details.ts

@@ -2,7 +2,7 @@
  * ReplDetails — structured payload for the repl() tool's AgentToolResult<T>.
  *
  * Mirrors RlmDetails but scoped to a single code execution. Sub-calls (llm_query,
- * rlm_query, load_library) triggered during sandbox execution are
+ * rlm_query, add_context) triggered during sandbox execution are
  * accumulated into the subcalls array for tree rendering.
  */
 

package/src/tool/repl-tool.ts

@@ -20,8 +20,8 @@ import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import type { Model, Usage, Api } from "@earendil-works/pi-ai";
 import type { ModelRegistry } from "@earendil-works/pi-coding-agent";
-import { buildLibraryHandler } from "../bridge/library.ts";
-import { libraryPrefixesIn } from "../context/library-context.ts";
+import { buildAddContextHandler, type AddContextHandlerBundle } from "../bridge/add-context.ts";
+import { contextPrefixesIn } from "../context/namespace.ts";
 import type { SubcallGates } from "../util/concurrency.ts";
 import { LimitGuard, limitsFromConfig } from "../core/limits.ts";
 import type { RlmConfig, RlmInput, RlmResult } from "../core/types.ts";
@@ -115,8 +115,13 @@ export interface ReplToolDeps {
   readonly signal?: AbortSignal;
   readonly onUsage?: (usage: Usage, role: "sub") => void;
   readonly ensureContext?: () => Promise<void>;
-  /** Register a reset hook for sandbox death/dispose (e.g. load_library slot counter). */
+  /** Register a reset hook for sandbox death/dispose (e.g. add_context prefix cache). */
   readonly registerDiscardHook?: (reset: () => void) => void;
+  /**
+   * Hands the live add_context bundle to the extension so the cwd seed can
+   * markLoaded("") / markSeededCwd(abs) — without this, add_context(".") doubles the tree.
+   */
+  readonly registerContextBundle?: (bundle: AddContextHandlerBundle) => void;
 }
 
 export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplToolParams, ReplDetails> {
@@ -159,15 +164,15 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
     signal,
     onUsage,
     runChild,
-    // The session sandbox's context is the child's world. Read lazily so a load_library from an
+    // The session sandbox's context is the child's world. Read lazily so an add_context from an
     // earlier repl() reaches a child spawned in a later one. Populated before any interrupt can
     // fire: execute() awaits ensureContext() before getOrCreate().
     getChildContext: () => sandboxManager.contextPayload ?? undefined,
     trackDetached: (task) => background.track(task),
   });
 
-  const libraryBundle = getConfig().libraryLoader
-    ? buildLibraryHandler({
+  const contextBundle = getConfig().contextLoader
+    ? buildAddContextHandler({
         getCwd: () => sessionCwd,
         getEmitter: () => bridgeState.currentEmitter,
         // Refuse pre-flight whatever the worker would reject, so host idempotency is never
@@ -177,14 +182,20 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
         signal,
         // Keep the manager's replay copy in step with the worker's live `context`, and with it
         // whatever a child spawned after this load will inherit.
-        onLoaded: (payload) => { sandboxManager.appendLibrary(payload); },
+        onLoaded: (payload) => { sandboxManager.appendContext(payload); },
       })
     : undefined;
-  if (libraryBundle) {
+  if (contextBundle) {
     // Re-derive the loaded-prefix cache from the payload that will actually be replayed —
-    // clearing it outright would make the host re-clone a library the recreated worker already has.
-    const bundle = libraryBundle;
-    deps.registerDiscardHook?.(() => bundle.reset(libraryPrefixesIn(sandboxManager.contextPayload)));
+    // clearing it outright would make the host re-clone a source the recreated worker already has.
+    // Re-plant the cwd sentinel if the seed is still in the payload (un-prefixed files).
+    const bundle = contextBundle;
+    deps.registerDiscardHook?.(() => {
+      const prefixes = contextPrefixesIn(sandboxManager.contextPayload);
+      bundle.reset(prefixes);
+      if (bundle.seededCwd() !== undefined) bundle.markLoaded("");
+    });
+    deps.registerContextBundle?.(contextBundle);
   }
 
   return {
@@ -192,14 +203,15 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
     label: "REPL",
     description:
       "PRIMARY tool for ALL repository reading and analysis (read/grep are disabled in RLM mode). " +
-      "Persistent Python sandbox with every file pre-loaded in `context`. Locate first with the " +
-      "free primitives search(query) / grep_context(pattern) / outline(path), then delegate the " +
-      "semantic reading to map_files / llm_query / llm_query_batched / llm_query_chunked " +
-      "(rlm_query for iterative sub-tasks) — stdout returned to you is hard-capped at 4K chars, " +
-      "so printing file bodies is useless. Variables, imports, and the `answers`/`plan` memo " +
-      "persist across calls. Also supports load_library.",
+      "Persistent Python sandbox with loaded files in `context` (starts empty; cwd seeds on first " +
+      "call). Locate first with the free primitives search(query) / grep_context(pattern) / " +
+      "outline(path), then delegate the semantic reading to map_files / llm_query / " +
+      "llm_query_batched / llm_query_chunked (rlm_query for iterative sub-tasks) — stdout " +
+      "returned to you is hard-capped at 4K chars, so printing file bodies is useless. " +
+      "Variables, imports, and the `answers`/`plan` memo persist across calls. Also supports " +
+      "add_context for external dirs/files/git URLs and document conversion.",
     promptSnippet:
-      "repl: run Python in a persistent sandbox holding the whole repository in `context`; " +
+      "repl: run Python in a persistent sandbox holding loaded files in `context`; " +
       "search/grep_context/outline to locate, map_files/llm_query* to read.",
     promptGuidelines: [
       "In RLM mode, read the repository through `repl` only — `read`/`grep` and bash readers are blocked.",
@@ -271,7 +283,7 @@ export function createReplTool(deps: ReplToolDeps): ToolDefinition<typeof ReplTo
         await deps.ensureContext?.();
         await sandboxManager.getOrCreate({
           ...subcallHandlers,
-          ...(libraryBundle?.handlers ?? {}),
+          ...(contextBundle?.handlers ?? {}),
         });
 
         // Detect queue contention AFTER sandbox init (initPromise settled, isExecuting now accurate)

package/src/tool/rlm-tool.ts

@@ -31,7 +31,7 @@ const CALL_PREVIEW_CHARS = 80;
 
 export const RlmToolParams = Object.freeze(Type.Object({
   prompt: Type.String({ description: "The task or question for the RLM engine" }),
-  context: Type.Optional(Type.String({ description: "Optional context. If omitted, repo is auto-packed via repomix." })),
+  context: Type.Optional(Type.String({ description: "Optional context. If omitted, the working directory is packed into context." })),
 }));
 
 // ── Rendering helpers ──

package/src/ui/config-panel.ts

@@ -20,7 +20,8 @@ const CHOICES = Object.freeze({
   rootSamplingMaxTokens: Object.freeze(["4096", "8192", "16384", "32768"]),
   sandboxInitTimeoutMs: Object.freeze(["10000", "30000", "60000", "120000"]),
   requestTimeoutMs: Object.freeze(["2", "5", "10", "20"]),
-  libraryLoader: Object.freeze(["on", "off"]),
+  contextLoader: Object.freeze(["on", "off"]),
+  autoSeedCwd: Object.freeze(["on", "off"]),
 });
 
 function item(id: string, label: string, currentValue: string, values: readonly string[], description: string): SettingItem {
@@ -49,8 +50,10 @@ export async function showConfigPanel(ctx: ExtensionContext, config: RlmConfig):
     item("rootSamplingMaxTokens", "Root model output cap (tok)", String(config.rootSampling?.maxTokens ?? 16384), CHOICES.rootSamplingMaxTokens, "Max output tokens per root-model turn. Lower values keep each turn lean."),
     item("sandboxInitTimeoutMs", "Sandbox init timeout", String(config.sandboxInitTimeoutMs), CHOICES.sandboxInitTimeoutMs, "How long to wait for the Python worker to start."),
     item("requestTimeoutMs", "Sandbox request timeout (min)", String(Math.round(config.requestTimeoutMs / 60_000)), CHOICES.requestTimeoutMs, "Parent-side watchdog per sandbox request; on breach the Python worker is killed."),
-    item("libraryLoader", "Library loader", config.libraryLoader ? "on" : "off", CHOICES.libraryLoader,
-      "Allow load_library() to pull an external dir, file, or git repo into the shared context list."),
+    item("contextLoader", "Context loader", config.contextLoader ? "on" : "off", CHOICES.contextLoader,
+      "Allow add_context() to pull an external dir, file, document, or git repo into context."),
+    item("autoSeedCwd", "Auto-seed cwd", config.autoSeedCwd ? "on" : "off", CHOICES.autoSeedCwd,
+      "Seed the working directory into context on the first repl() call (otherwise starts empty)."),
     item("__save__", "Save & close", "↵", ["↵"], "Save these settings and close (Esc also saves)."),
   ];
 
@@ -104,7 +107,8 @@ export function applySetting(config: RlmConfig, id: string, value: string): RlmC
       return Object.freeze({ ...config, rootSampling: Object.freeze({ ...config.rootSampling, maxTokens: Number(value) }) });
     case "sandboxInitTimeoutMs": return Object.freeze({ ...config, sandboxInitTimeoutMs: Number(value) });
     case "requestTimeoutMs": return Object.freeze({ ...config, requestTimeoutMs: Number(value) * 60_000 });
-    case "libraryLoader": return Object.freeze({ ...config, libraryLoader: value === "on" });
+    case "contextLoader": return Object.freeze({ ...config, contextLoader: value === "on" });
+    case "autoSeedCwd": return Object.freeze({ ...config, autoSeedCwd: value === "on" });
     default: return config;
   }
 }

package/src/bridge/library.ts

@@ -1,190 +0,0 @@
-/**
- * Shared load_library handler for headless engine and native repl() mode.
- *
- * Host packs the source via resolveLibrarySource (namespaced under lib/<id>/) and returns the
- * payload for the worker to append into the single `context` list.
- *
- * Idempotency is host-side: re-loading a source that was already packed does not re-clone or
- * re-pack, and the prefix set is the only state that decides it.
- *
- * Late-bound deps (getCwd / getEmitter) keep a single handler closure correct
- * across native repl() calls — getOrCreate only installs handlers at spawn.
- */
-
-import type { RlmEmitter } from "../tool/rlm-events.ts";
-import type { SubLlmHandlers } from "../sandbox/sandbox.ts";
-import {
-  libraryNamespace,
-  resolveLibrarySource,
-} from "../context/library-context.ts";
-import { previewText } from "../text/preview.ts";
-
-export interface LibraryBridgeOpts {
-  /** Fixed cwd (headless). Prefer getCwd when the sandbox outlives a single invocation. */
-  readonly cwd?: string;
-  /** Late-bound cwd (native mode — sandbox handlers outlive a single repl()). */
-  readonly getCwd?: () => string;
-  readonly emitter?: RlmEmitter;
-  /** Native mode: read the live emitter each call. */
-  readonly getEmitter?: () => RlmEmitter | null | undefined;
-  readonly parentId?: string;
-  readonly signal?: AbortSignal;
-  /** Prefixes already present in context — seeds host-side idempotency after a sandbox restart. */
-  readonly loadedPrefixes?: readonly string[];
-  /**
-   * The live context this sandbox holds. Read to refuse pre-flight exactly what the worker's
-   * `_append_library` would reject, before any prefix is committed.
-   */
-  readonly getContext?: () => unknown;
-  /**
-   * Post-load hook. The engine grows its live context here; native mode grows
-   * SandboxManager.contextPayload.
-   */
-  readonly onLoaded?: (payload: unknown) => void | Promise<void>;
-}
-
-export interface LibraryHandlerBundle {
-  readonly handlers: Pick<SubLlmHandlers, "loadLibrary">;
-  /**
-   * Reset the loaded-prefix cache (call when the sandbox is
-   * discarded and will re-spawn).
-   *
-   * `keep` re-seeds the cache from the payload that will be replayed into the fresh worker.
-   * `loaded` is a CACHE of `libraryPrefixesIn(context)`, never independent state, so it may only
-   * be cleared by re-deriving it — clearing it outright would make the host re-clone and re-pack
-   * a library the recreated worker already holds.
-   */
-  readonly reset: (keep?: readonly string[]) => void;
-  /** Prefixes loaded in this sandbox lifetime (for tests). */
-  readonly loadedPrefixes: () => ReadonlySet<string>;
-}
-
-/**
- * JS runtime kind → the Python type name worker.py reports, so both sides emit exactly one
- * message for the same refusal. Covers every shape a context payload can take after JSON
- * transport; anything else is a plain object, which `json.load` materializes as a dict.
- */
-const PY_TYPE_NAME: Readonly<Record<string, string>> = Object.freeze({
-  string: "str", boolean: "bool", number: "int", bigint: "int", undefined: "None",
-});
-
-function pythonKindOf(value: unknown): string {
-  if (value === null) return "None"; // matches worker.py's `if ctx is not None else "None"`
-  return PY_TYPE_NAME[typeof value] ?? "dict";
-}
-
-/**
- * Refusal messages shared with worker.py `_append_library`. The worker is the backstop; the host
- * pre-flights the same two conditions so it never commits a prefix for an append that
- * will be rejected. Keep the wording identical — a comment in worker.py points back here.
- */
-const LIST_CONTEXT_REQUIRED = (kind: string): string =>
-  `load_library requires list context (file bundle); got ${kind}`;
-const NO_FILES_PRODUCED = "load_library produced no files";
-
-export function buildLibraryHandler(opts: LibraryBridgeOpts): LibraryHandlerBundle {
-  /** Prefixes already loaded in this sandbox — mirrors the worker's context state. */
-  const loaded = new Set<string>(opts.loadedPrefixes ?? []);
-  return {
-    reset: (keep) => {
-      const seed = keep ?? opts.loadedPrefixes ?? [];
-      loaded.clear();
-      for (const prefix of seed) loaded.add(prefix);
-    },
-    loadedPrefixes: () => loaded,
-    handlers: {
-      async loadLibrary(source, depth) {
-        const emitter = opts.getEmitter?.() ?? opts.emitter;
-        const cwd = opts.getCwd?.() ?? opts.cwd;
-        if (cwd === undefined || cwd === "") {
-          throw new Error("load_library: no cwd configured");
-        }
-        const id = emitter?.emitSubcallCreated({
-          kind: "tool", parentId: opts.parentId,
-          label: "load_library",
-          args: previewText(source, 80),
-          depth,
-        });
-        try {
-          // Pre-flight the worker's own refusal: a non-list context cannot be appended to, and
-          // committing a prefix for it would make the NEXT load lie with already_loaded.
-          const current = opts.getContext?.();
-          if (current !== undefined && !Array.isArray(current)) {
-            throw new Error(LIST_CONTEXT_REQUIRED(pythonKindOf(current)));
-          }
-
-          // Cheap pre-check BEFORE cloning/packing: same namespace ⇒ nothing to do.
-          const { sourceId: preId, pathPrefix: prefix } = libraryNamespace(source, cwd);
-          if (loaded.has(prefix)) {
-            if (id) {
-              emitter?.emitSubcallUpdated({
-                id,
-                status: "done",
-                resultPreview: `already loaded (${prefix}*)`,
-              });
-            }
-            return {
-              payload: Object.freeze([]),
-              files: 0,
-              chars: 0,
-              sourceId: preId,
-              pathPrefix: prefix,
-              alreadyLoaded: true,
-            };
-          }
-
-          const resolved = await resolveLibrarySource(source, cwd, opts.signal);
-          if (!resolved.ok) throw new Error(resolved.error);
-          const { payload, files, chars, sourceId, pathPrefix } = resolved.value;
-          // The worker's other refusal, pre-flighted for the same reason.
-          if (payload.length === 0) throw new Error(NO_FILES_PRODUCED);
-
-          // Race: another concurrent load of the same prefix finished while we packed.
-          if (loaded.has(pathPrefix)) {
-            if (id) {
-              emitter?.emitSubcallUpdated({
-                id,
-                status: "done",
-                resultPreview: `already loaded (${pathPrefix}*)`,
-              });
-            }
-            return {
-              payload: Object.freeze([]),
-              files: 0,
-              chars: 0,
-              sourceId,
-              pathPrefix,
-              alreadyLoaded: true,
-            };
-          }
-
-          // Mark loaded only after the host has grown its own copy of the context.
-          if (opts.onLoaded) {
-            await opts.onLoaded(payload);
-          }
-          loaded.add(pathPrefix);
-
-          if (id) {
-            emitter?.emitSubcallUpdated({
-              id,
-              status: "done",
-              resultPreview:
-                `+${files} file(s) → context (${pathPrefix}*, ${chars.toLocaleString()} chars)`,
-            });
-          }
-          return {
-            payload,
-            files,
-            chars,
-            sourceId,
-            pathPrefix,
-            alreadyLoaded: false,
-          };
-        } catch (err) {
-          if (id) emitter?.emitSubcallUpdated({ id, status: "error", detail: String(err) });
-          throw err;   // serviceInterrupt catch → {error} reply → "Error: …" in the REPL
-        }
-      },
-    },
-  };
-}